├── .clang-tidy ├── .gitignore ├── .gn ├── BUILD.gn ├── Dockerfile ├── Makefile ├── Readme.md ├── Readme_zh.md ├── build ├── build.sh ├── config.gni ├── config │ └── BUILDCONFIG.gn ├── core │ ├── genmplt.mk │ ├── java2jar.mk │ ├── maple_test.mk │ ├── maple_variables.mk │ └── mplcomb.mk ├── envsetup.sh ├── logs │ └── .gitignore ├── maplelld.so.lds └── toolchain │ └── BUILD.gn ├── doc ├── cn │ ├── CPPCodingTalkAboutPointer.md │ ├── CompilerPhaseDescription.md │ ├── DeveloperGuide.md │ ├── DeveloperGuide4Utility.md │ ├── DevelopmentPreparation.md │ ├── NaiveRcInsertionDescription.md │ ├── ProgrammingSpecifications.md │ ├── RcApi.md │ ├── VtableItableDescription.md │ └── media │ │ ├── Topology.png │ │ ├── addphase.png │ │ ├── interface1.jpg │ │ └── javavmt.png └── en │ ├── CPPCodingTalkAboutPointer.md │ ├── CompilerPhaseDescription.md │ ├── DeveloperGuide.md │ ├── DeveloperGuide4Utility.md │ ├── DevelopmentPreparation.md │ ├── MapleIRDesign.md │ ├── NaiveRcInsertionDescription.md │ ├── ProgrammingSpecifications.md │ ├── RcApi.md │ ├── VtableItableDescription.md │ └── media │ ├── Topology.png │ ├── addphase.png │ ├── interface1.jpg │ └── javavmt.png ├── license └── LICENSE ├── samples ├── exceptiontest │ ├── Arith.java │ └── Makefile ├── helloworld │ ├── HelloWorld.java │ └── Makefile ├── iteratorandtemplate │ ├── IteratorAndTemplateTest.java │ └── Makefile ├── polymorphismtest │ ├── InterfaceTest.java │ └── Makefile ├── rccycletest │ ├── Makefile │ └── RCCycleTest.java └── threadtest │ ├── Makefile │ └── ThreadTest.java ├── src ├── BUILD.gn ├── bin │ ├── java2jar │ ├── jbc2mpl │ └── maple ├── deplibs │ ├── libmempool.a │ ├── libmplphase.a │ └── libmplutil.a ├── huawei_secure_c │ ├── BUILD.gn │ ├── include │ │ ├── securec.h │ │ └── securectype.h │ └── src │ │ ├── fscanf_s.c │ │ ├── fwscanf_s.c │ │ ├── gets_s.c │ │ ├── input.inl │ │ ├── memcpy_s.c │ │ ├── memmove_s.c │ │ ├── memset_s.c │ │ ├── output.inl │ │ ├── scanf_s.c │ │ ├── secinput.h │ │ ├── securecutil.c │ │ ├── securecutil.h │ │ ├── secureinput_a.c │ │ ├── secureinput_w.c │ │ ├── secureprintoutput.h │ │ ├── secureprintoutput_a.c │ │ ├── secureprintoutput_w.c │ │ ├── snprintf_s.c │ │ ├── sprintf_s.c │ │ ├── sscanf_s.c │ │ ├── strcat_s.c │ │ ├── strcpy_s.c │ │ ├── strncat_s.c │ │ ├── strncpy_s.c │ │ ├── strtok_s.c │ │ ├── swprintf_s.c │ │ ├── swscanf_s.c │ │ ├── vfscanf_s.c │ │ ├── vfwscanf_s.c │ │ ├── vscanf_s.c │ │ ├── vsnprintf_s.c │ │ ├── vsprintf_s.c │ │ ├── vsscanf_s.c │ │ ├── vswprintf_s.c │ │ ├── vswscanf_s.c │ │ ├── vwscanf_s.c │ │ ├── wcscat_s.c │ │ ├── wcscpy_s.c │ │ ├── wcsncat_s.c │ │ ├── wcsncpy_s.c │ │ ├── wcstok_s.c │ │ ├── wmemcpy_s.c │ │ ├── wmemmove_s.c │ │ └── wscanf_s.c ├── maple_be │ ├── BUILD.gn │ ├── include │ │ ├── ad │ │ │ ├── cortex_a55 │ │ │ │ └── sched_cortex_a55.td │ │ │ ├── mad.h │ │ │ └── target │ │ │ │ ├── mplad_arch_define.def │ │ │ │ ├── mplad_bypass_define.def │ │ │ │ ├── mplad_latency_type.def │ │ │ │ ├── mplad_reservation_define.def │ │ │ │ ├── mplad_unit_define.def │ │ │ │ ├── mplad_unit_id.def │ │ │ │ ├── mplad_unit_kind.def │ │ │ │ └── mplad_unit_name.def │ │ ├── be │ │ │ ├── aarch64 │ │ │ │ └── aarch64_rt.h │ │ │ ├── array_base_name.def │ │ │ ├── array_klass_name.def │ │ │ ├── bbt.h │ │ │ ├── becommon.h │ │ │ ├── common_utils.h │ │ │ ├── lower.h │ │ │ ├── rt.h │ │ │ ├── switch_lowerer.h │ │ │ └── try_catch.h │ │ └── cg │ │ │ ├── aarch64 │ │ │ ├── aarch64_abi.h │ │ │ ├── aarch64_args.h │ │ │ ├── aarch64_cc.def │ │ │ ├── aarch64_cg.h │ │ │ ├── aarch64_cgfunc.h │ │ │ ├── aarch64_color_ra.h │ │ │ ├── aarch64_dependence.h │ │ │ ├── aarch64_ebo.h │ │ │ ├── aarch64_emitter.h │ │ │ ├── aarch64_fixshortbranch.h │ │ │ ├── aarch64_fp_simd_regs.def │ │ │ ├── aarch64_global.h │ │ │ ├── aarch64_ico.h │ │ │ ├── aarch64_immediate.h │ │ │ ├── aarch64_insn.h │ │ │ ├── aarch64_int_regs.def │ │ │ ├── aarch64_isa.def │ │ │ ├── aarch64_isa.h │ │ │ ├── aarch64_live.h │ │ │ ├── aarch64_memlayout.h │ │ │ ├── aarch64_offset_adjust.h │ │ │ ├── aarch64_operand.h │ │ │ ├── aarch64_optimize_common.h │ │ │ ├── aarch64_peep.h │ │ │ ├── aarch64_proepilog.h │ │ │ ├── aarch64_reaching.h │ │ │ ├── aarch64_reg_alloc.h │ │ │ ├── aarch64_schedule.h │ │ │ ├── aarch64_strldr.h │ │ │ ├── aarch64_yieldpoint.h │ │ │ └── mpl_atomic.h │ │ │ ├── args.h │ │ │ ├── asm_emit.h │ │ │ ├── asm_info.h │ │ │ ├── cfgo.h │ │ │ ├── cfi.def │ │ │ ├── cfi.h │ │ │ ├── cg.h │ │ │ ├── cg_cfg.h │ │ │ ├── cg_option.h │ │ │ ├── cg_phase.h │ │ │ ├── cg_phasemanager.h │ │ │ ├── cg_phases.def │ │ │ ├── cgbb.h │ │ │ ├── cgfunc.h │ │ │ ├── datainfo.h │ │ │ ├── dependence.h │ │ │ ├── deps.h │ │ │ ├── ebo.h │ │ │ ├── eh_func.h │ │ │ ├── emit.h │ │ │ ├── global.h │ │ │ ├── ico.h │ │ │ ├── insn.h │ │ │ ├── isa.h │ │ │ ├── label_creation.h │ │ │ ├── live.h │ │ │ ├── loop.h │ │ │ ├── lsda.h │ │ │ ├── memlayout.h │ │ │ ├── offset_adjust.h │ │ │ ├── operand.h │ │ │ ├── optimize_common.h │ │ │ ├── peep.h │ │ │ ├── pressure.h │ │ │ ├── proepilog.h │ │ │ ├── reaching.h │ │ │ ├── reg_alloc.h │ │ │ ├── schedule.h │ │ │ ├── strldr.h │ │ │ └── yieldpoint.h │ ├── mdgen │ │ ├── gendef.py │ │ ├── include │ │ │ ├── mdgenerator.h │ │ │ ├── mdlexer.h │ │ │ ├── mdparser.h │ │ │ ├── mdrecord.h │ │ │ └── mdtokens.h │ │ └── src │ │ │ ├── mdgenerator.cpp │ │ │ ├── mdlexer.cpp │ │ │ ├── mdmain.cpp │ │ │ ├── mdparser.cpp │ │ │ └── mdrecord.cpp │ └── src │ │ ├── ad │ │ └── mad.cpp │ │ ├── be │ │ ├── bbt.cpp │ │ ├── becommon.cpp │ │ ├── lower.cpp │ │ ├── rt.cpp │ │ ├── switch_lowerer.cpp │ │ └── trycatchblockslower.cpp │ │ └── cg │ │ ├── aarch64 │ │ ├── aarch64_abi.cpp │ │ ├── aarch64_args.cpp │ │ ├── aarch64_cg.cpp │ │ ├── aarch64_cgfunc.cpp │ │ ├── aarch64_color_ra.cpp │ │ ├── aarch64_dependence.cpp │ │ ├── aarch64_ebo.cpp │ │ ├── aarch64_emitter.cpp │ │ ├── aarch64_fixshortbranch.cpp │ │ ├── aarch64_global.cpp │ │ ├── aarch64_ico.cpp │ │ ├── aarch64_immediate.cpp │ │ ├── aarch64_insn.cpp │ │ ├── aarch64_isa.cpp │ │ ├── aarch64_live.cpp │ │ ├── aarch64_md.def │ │ ├── aarch64_memlayout.cpp │ │ ├── aarch64_offset_adjust.cpp │ │ ├── aarch64_operand.cpp │ │ ├── aarch64_opnd.def │ │ ├── aarch64_optimize_common.cpp │ │ ├── aarch64_peep.cpp │ │ ├── aarch64_proepilog.cpp │ │ ├── aarch64_reaching.cpp │ │ ├── aarch64_reg_alloc.cpp │ │ ├── aarch64_schedule.cpp │ │ ├── aarch64_strldr.cpp │ │ ├── aarch64_yieldpoint.cpp │ │ └── mpl_atomic.cpp │ │ ├── args.cpp │ │ ├── cfgo.cpp │ │ ├── cfi.cpp │ │ ├── cg.cpp │ │ ├── cg_cfg.cpp │ │ ├── cg_option.cpp │ │ ├── cg_phasemanager.cpp │ │ ├── cgbb.cpp │ │ ├── cgfunc.cpp │ │ ├── ebo.cpp │ │ ├── eh_func.cpp │ │ ├── emit.cpp │ │ ├── global.cpp │ │ ├── ico.cpp │ │ ├── label_creation.cpp │ │ ├── live.cpp │ │ ├── loop.cpp │ │ ├── memlayout.cpp │ │ ├── offset_adjust.cpp │ │ ├── optimize_common.cpp │ │ ├── peep.cpp │ │ ├── pressure.cpp │ │ ├── proepilog.cpp │ │ ├── reaching.cpp │ │ ├── schedule.cpp │ │ ├── script │ │ └── genmop.py │ │ ├── strldr.cpp │ │ └── yieldpoint.cpp ├── maple_driver │ ├── BUILD.gn │ ├── defs │ │ ├── default │ │ │ ├── O0_options_jbc2mpl.def │ │ │ ├── O0_options_me.def │ │ │ ├── O0_options_mpl2mpl.def │ │ │ ├── O0_options_mplcg.def │ │ │ ├── O2_options_me.def │ │ │ ├── O2_options_mpl2mpl.def │ │ │ └── O2_options_mplcg.def │ │ ├── default_options.def │ │ └── phases.def │ ├── include │ │ ├── compiler.h │ │ ├── compiler_factory.h │ │ ├── compiler_selector.h │ │ ├── driver_option_common.h │ │ ├── driver_runner.h │ │ ├── file_utils.h │ │ ├── jbc2mpl_option.h │ │ ├── mpl_options.h │ │ ├── option_descriptor.h │ │ ├── option_parser.h │ │ └── safe_exe.h │ └── src │ │ ├── compiler.cpp │ │ ├── compiler_factory.cpp │ │ ├── compiler_selector.cpp │ │ ├── driver_option_common.cpp │ │ ├── driver_runner.cpp │ │ ├── file_utils.cpp │ │ ├── jbc2mpl_compiler.cpp │ │ ├── maple.cpp │ │ ├── maple_comb_compiler.cpp │ │ ├── mpl_options.cpp │ │ ├── mplcg_compiler.cpp │ │ └── option_parser.cpp ├── maple_ipa │ ├── BUILD.gn │ ├── include │ │ ├── call_graph.h │ │ ├── clone.h │ │ ├── interleaved_manager.h │ │ ├── module_phase.h │ │ ├── module_phase_manager.h │ │ ├── module_phases.def │ │ └── retype.h │ └── src │ │ ├── call_graph.cpp │ │ ├── clone.cpp │ │ ├── interleaved_manager.cpp │ │ ├── module_phase_manager.cpp │ │ └── retype.cpp ├── maple_ir │ ├── BUILD.gn │ ├── include │ │ ├── all_attributes.def │ │ ├── bin_mir_file.h │ │ ├── bin_mpl_export.h │ │ ├── bin_mpl_import.h │ │ ├── bin_mplt.h │ │ ├── binary_op.def │ │ ├── cfg_primitive_types.h │ │ ├── global_tables.h │ │ ├── intrinsic_java.def │ │ ├── intrinsic_op.h │ │ ├── intrinsics.def │ │ ├── intrinsics.h │ │ ├── ir_safe_cast_traits.def │ │ ├── java_eh_lower.h │ │ ├── keywords.def │ │ ├── lexer.h │ │ ├── memory_order_attrs.def │ │ ├── metadata_layout.h │ │ ├── mir_builder.h │ │ ├── mir_config.h │ │ ├── mir_const.h │ │ ├── mir_function.h │ │ ├── mir_lower.h │ │ ├── mir_module.h │ │ ├── mir_nodes.h │ │ ├── mir_parser.h │ │ ├── mir_pragma.h │ │ ├── mir_preg.h │ │ ├── mir_symbol.h │ │ ├── mir_symbol_builder.h │ │ ├── mir_type.h │ │ ├── opcode_info.h │ │ ├── opcodes.def │ │ ├── opcodes.h │ │ ├── option.h │ │ ├── parser_opt.h │ │ ├── prim_types.def │ │ ├── prim_types.h │ │ ├── printing.h │ │ ├── simplifyintrinsics.def │ │ ├── tokens.h │ │ ├── types_def.h │ │ └── unary_op.def │ └── src │ │ ├── bin_mpl_export.cpp │ │ ├── bin_mpl_import.cpp │ │ ├── driver.cpp │ │ ├── global_tables.cpp │ │ ├── intrinsics.cpp │ │ ├── lexer.cpp │ │ ├── mir_builder.cpp │ │ ├── mir_const.cpp │ │ ├── mir_function.cpp │ │ ├── mir_lower.cpp │ │ ├── mir_module.cpp │ │ ├── mir_nodes.cpp │ │ ├── mir_parser.cpp │ │ ├── mir_pragma.cpp │ │ ├── mir_symbol.cpp │ │ ├── mir_symbol_builder.cpp │ │ ├── mir_type.cpp │ │ ├── opcode_info.cpp │ │ ├── option.cpp │ │ ├── parser.cpp │ │ └── printing.cpp ├── maple_me │ ├── BUILD.gn │ ├── include │ │ ├── alias_analysis_table.h │ │ ├── alias_class.h │ │ ├── bb.h │ │ ├── dominance.h │ │ ├── dse.h │ │ ├── func_emit.h │ │ ├── hdse.h │ │ ├── irmap.h │ │ ├── me_abco.h │ │ ├── me_alias_class.h │ │ ├── me_analyze_rc.h │ │ ├── me_analyzector.h │ │ ├── me_bb_layout.h │ │ ├── me_builder.h │ │ ├── me_bypath_eh.h │ │ ├── me_cfg.h │ │ ├── me_cfg_mst.h │ │ ├── me_cond_based.h │ │ ├── me_cond_based_npc.h │ │ ├── me_cond_based_rc.h │ │ ├── me_const.h │ │ ├── me_critical_edge.h │ │ ├── me_delegate_rc.h │ │ ├── me_dominance.h │ │ ├── me_dse.h │ │ ├── me_emit.h │ │ ├── me_function.h │ │ ├── me_hdse.h │ │ ├── me_inequality_graph.h │ │ ├── me_ir.h │ │ ├── me_irmap.h │ │ ├── me_loop_analysis.h │ │ ├── me_loop_canon.h │ │ ├── me_lower_globals.h │ │ ├── me_may2dassign.h │ │ ├── me_option.h │ │ ├── me_pgo_instrument.h │ │ ├── me_phase.h │ │ ├── me_phase_manager.h │ │ ├── me_phases.def │ │ ├── me_profile_gen.h │ │ ├── me_profile_use.h │ │ ├── me_prop.h │ │ ├── me_rc_lowering.h │ │ ├── me_rename2preg.h │ │ ├── me_safe_cast_traits.def │ │ ├── me_ssa.h │ │ ├── me_ssa_devirtual.h │ │ ├── me_ssa_epre.h │ │ ├── me_ssa_lpre.h │ │ ├── me_ssa_tab.h │ │ ├── me_ssa_update.h │ │ ├── me_ssi.h │ │ ├── me_ssu_pre.h │ │ ├── me_stmt_pre.h │ │ ├── me_store_pre.h │ │ ├── occur.h │ │ ├── orig_symbol.h │ │ ├── preg_renamer.h │ │ ├── prop.h │ │ ├── ssa.h │ │ ├── ssa_devirtual.h │ │ ├── ssa_epre.h │ │ ├── ssa_mir_nodes.h │ │ ├── ssa_pre.h │ │ ├── ssa_tab.h │ │ ├── union_find.h │ │ └── ver_symbol.h │ └── src │ │ ├── alias_analysis_table.cpp │ │ ├── alias_class.cpp │ │ ├── bb.cpp │ │ ├── dominance.cpp │ │ ├── dse.cpp │ │ ├── func_emit.cpp │ │ ├── hdse.cpp │ │ ├── irmap.cpp │ │ ├── irmap_emit.cpp │ │ ├── me_abco.cpp │ │ ├── me_alias_class.cpp │ │ ├── me_analyze_rc.cpp │ │ ├── me_analyzector.cpp │ │ ├── me_bb_layout.cpp │ │ ├── me_builder.cpp │ │ ├── me_bypath_eh.cpp │ │ ├── me_cfg.cpp │ │ ├── me_cond_based_opt.cpp │ │ ├── me_critical_edge.cpp │ │ ├── me_delegate_rc.cpp │ │ ├── me_dominance.cpp │ │ ├── me_dse.cpp │ │ ├── me_emit.cpp │ │ ├── me_function.cpp │ │ ├── me_hdse.cpp │ │ ├── me_inequality_graph.cpp │ │ ├── me_ir.cpp │ │ ├── me_irmap.cpp │ │ ├── me_loop_analysis.cpp │ │ ├── me_loop_canon.cpp │ │ ├── me_lower_globals.cpp │ │ ├── me_may2dassign.cpp │ │ ├── me_option.cpp │ │ ├── me_phase_manager.cpp │ │ ├── me_profile_gen.cpp │ │ ├── me_profile_use.cpp │ │ ├── me_prop.cpp │ │ ├── me_rc_lowering.cpp │ │ ├── me_rename2preg.cpp │ │ ├── me_ssa.cpp │ │ ├── me_ssa_devirtual.cpp │ │ ├── me_ssa_epre.cpp │ │ ├── me_ssa_lpre.cpp │ │ ├── me_ssa_tab.cpp │ │ ├── me_ssa_update.cpp │ │ ├── me_ssi.cpp │ │ ├── me_ssu_pre.cpp │ │ ├── me_stmt_fre.cpp │ │ ├── me_stmt_pre.cpp │ │ ├── me_store_pre.cpp │ │ ├── occur.cpp │ │ ├── orig_symbol.cpp │ │ ├── preg_renamer.cpp │ │ ├── prop.cpp │ │ ├── ssa.cpp │ │ ├── ssa_devirtual.cpp │ │ ├── ssa_epre.cpp │ │ ├── ssa_mir_nodes.cpp │ │ ├── ssa_pre.cpp │ │ ├── ssa_tab.cpp │ │ └── ver_symbol.cpp ├── maple_phase │ └── include │ │ ├── phase.h │ │ ├── phase_impl.h │ │ └── phase_manager.h ├── maple_util │ ├── include │ │ ├── error_code.h │ │ ├── factory.h │ │ ├── file_layout.h │ │ ├── itab_util.h │ │ ├── literalstrname.h │ │ ├── mpl_logging.h │ │ ├── mpl_number.h │ │ ├── mpl_scheduler.h │ │ ├── mpl_timer.h │ │ ├── muid.h │ │ ├── namemangler.h │ │ ├── profile.h │ │ ├── profile_type.h │ │ ├── ptr.h │ │ ├── ptr_list_ref.h │ │ ├── safe_cast.h │ │ ├── safe_ptr.h │ │ ├── string_utils.h │ │ ├── utils.h │ │ ├── utils │ │ │ ├── iterator.h │ │ │ ├── meta.h │ │ │ └── ref_vector.h │ │ └── version.h │ └── src │ │ └── profile.cpp ├── mempool │ └── include │ │ ├── maple_string.h │ │ ├── mempool.h │ │ └── mempool_allocator.h ├── mpl2mpl │ ├── BUILD.gn │ ├── include │ │ ├── annotation_analysis.h │ │ ├── class_hierarchy.h │ │ ├── class_init.h │ │ ├── coderelayout.h │ │ ├── constantfold.h │ │ ├── gen_check_cast.h │ │ ├── java_intrn_lowering.h │ │ ├── muid_replacement.h │ │ ├── native_stub_func.h │ │ ├── reflection_analysis.h │ │ ├── vtable_analysis.h │ │ └── vtable_impl.h │ └── src │ │ ├── annotation_analysis.cpp │ │ ├── class_hierarchy.cpp │ │ ├── class_init.cpp │ │ ├── coderelayout.cpp │ │ ├── constantfold.cpp │ │ ├── gen_check_cast.cpp │ │ ├── java_eh_lower.cpp │ │ ├── java_intrn_lowering.cpp │ │ ├── muid_replacement.cpp │ │ ├── native_stub_func.cpp │ │ ├── reflection_analysis.cpp │ │ ├── vtable_analysis.cpp │ │ └── vtable_impl.cpp └── mplfe │ ├── BUILD.gn │ ├── common │ ├── include │ │ ├── base64.h │ │ ├── basic_io.h │ │ ├── fe_algorithm.h │ │ ├── fe_config_parallel.h │ │ ├── fe_configs.h │ │ ├── fe_errno.h │ │ ├── fe_file_ops.h │ │ ├── fe_file_type.h │ │ ├── fe_function.h │ │ ├── fe_function_phase_result.h │ │ ├── fe_input.h │ │ ├── fe_input_helper.h │ │ ├── fe_java_string_manager.h │ │ ├── fe_macros.h │ │ ├── fe_manager.h │ │ ├── fe_options.h │ │ ├── fe_struct_elem_info.h │ │ ├── fe_timer.h │ │ ├── fe_timer_ns.h │ │ ├── fe_type_hierarchy.h │ │ ├── fe_type_manager.h │ │ ├── fe_utils.h │ │ ├── fe_utils_java.h │ │ ├── feir_bb.h │ │ ├── feir_builder.h │ │ ├── feir_dfg.h │ │ ├── feir_stmt.h │ │ ├── feir_type.h │ │ ├── feir_type_helper.h │ │ ├── feir_type_infer.h │ │ ├── feir_var.h │ │ ├── feir_var_name.h │ │ ├── feir_var_reg.h │ │ ├── feir_var_type_scatter.h │ │ ├── general_bb.h │ │ ├── general_cfg.h │ │ ├── general_stmt.h │ │ ├── mplfe_compiler.h │ │ ├── mplfe_compiler_component.h │ │ ├── mplfe_env.h │ │ ├── mplfe_options.h │ │ ├── simple_xml.h │ │ └── simple_zip.h │ └── src │ │ ├── base64.cpp │ │ ├── basic_io.cpp │ │ ├── fe_config_parallel.cpp │ │ ├── fe_file_ops.cpp │ │ ├── fe_file_type.cpp │ │ ├── fe_function.cpp │ │ ├── fe_function_phase_result.cpp │ │ ├── fe_input.cpp │ │ ├── fe_input_helper.cpp │ │ ├── fe_java_string_manager.cpp │ │ ├── fe_manager.cpp │ │ ├── fe_options.cpp │ │ ├── fe_struct_elem_info.cpp │ │ ├── fe_timer_ns.cpp │ │ ├── fe_type_hierarchy.cpp │ │ ├── fe_type_manager.cpp │ │ ├── fe_utils.cpp │ │ ├── fe_utils_java.cpp │ │ ├── feir_builder.cpp │ │ ├── feir_dfg.cpp │ │ ├── feir_stmt.cpp │ │ ├── feir_type.cpp │ │ ├── feir_type_helper.cpp │ │ ├── feir_type_infer.cpp │ │ ├── feir_var.cpp │ │ ├── feir_var_name.cpp │ │ ├── feir_var_reg.cpp │ │ ├── feir_var_type_scatter.cpp │ │ ├── general_bb.cpp │ │ ├── general_cfg.cpp │ │ ├── general_stmt.cpp │ │ ├── mplfe.cpp │ │ ├── mplfe_compiler.cpp │ │ ├── mplfe_compiler_component.cpp │ │ ├── mplfe_env.cpp │ │ ├── mplfe_options.cpp │ │ ├── simple_xml.cpp │ │ └── simple_zip.cpp │ ├── doc │ ├── feir_design.md │ └── mplfe_guide.md │ ├── jbc_input │ ├── include │ │ ├── jbc_attr.def │ │ ├── jbc_attr.h │ │ ├── jbc_attr_item.h │ │ ├── jbc_bb.h │ │ ├── jbc_class.h │ │ ├── jbc_class2fe_helper.h │ │ ├── jbc_class_access.h │ │ ├── jbc_class_builder.h │ │ ├── jbc_class_const.def │ │ ├── jbc_class_const.h │ │ ├── jbc_class_const_pool.h │ │ ├── jbc_class_header.h │ │ ├── jbc_compiler_component.h │ │ ├── jbc_function.h │ │ ├── jbc_function_context.h │ │ ├── jbc_input.h │ │ ├── jbc_opcode.def │ │ ├── jbc_opcode.h │ │ ├── jbc_opcode_helper.h │ │ ├── jbc_opcode_kind.def │ │ ├── jbc_stack2fe_helper.h │ │ ├── jbc_stack_helper.h │ │ ├── jbc_stmt.h │ │ └── jbc_util.h │ └── src │ │ ├── jbc_attr.cpp │ │ ├── jbc_attr_item.cpp │ │ ├── jbc_bb.cpp │ │ ├── jbc_class.cpp │ │ ├── jbc_class2fe_helper.cpp │ │ ├── jbc_class_const.cpp │ │ ├── jbc_class_const_pool.cpp │ │ ├── jbc_class_header.cpp │ │ ├── jbc_compiler_component.cpp │ │ ├── jbc_function.cpp │ │ ├── jbc_function_context.cpp │ │ ├── jbc_input.cpp │ │ ├── jbc_opcode.cpp │ │ ├── jbc_opcode_helper.cpp │ │ ├── jbc_stack2fe_helper.cpp │ │ ├── jbc_stack_helper.cpp │ │ ├── jbc_stmt.cpp │ │ └── jbc_util.cpp │ └── test │ ├── BUILD.gn │ ├── base64_test.cpp │ ├── basic_io_test.cpp │ ├── fe_algorithm_test.cpp │ ├── fe_file_ops_test.cpp │ ├── fe_file_type_test.cpp │ ├── fe_function_process_schedular_test.cpp │ ├── fe_function_test.cpp │ ├── fe_struct_elem_info_test.cpp │ ├── fe_type_hierarchy_test.cpp │ ├── fe_type_manager_test.cpp │ ├── fe_utils_test.cpp │ ├── feir_builder_test.cpp │ ├── feir_stmt_dfg_test.cpp │ ├── feir_stmt_loc_test.cpp │ ├── feir_stmt_test.cpp │ ├── feir_test_base.cpp │ ├── feir_test_base.h │ ├── feir_type_helper_test.cpp │ ├── feir_type_infer_test.cpp │ ├── feir_type_test.cpp │ ├── feir_var_test.cpp │ ├── jbc_class2fe_helper_test.cpp │ ├── jbc_class_const_test.cpp │ ├── jbc_class_test.cpp │ ├── jbc_function_test.cpp │ ├── jbc_input │ └── JBC0001 │ │ ├── Test.class │ │ └── Test.java │ ├── jbc_opcode_helper_test.cpp │ ├── jbc_stack2fe_helper_test.cpp │ ├── jbc_stack_helper_test.cpp │ ├── jbc_util_test.cpp │ ├── mplfeUT.cpp │ ├── mplfe_ut.h │ ├── mplfe_ut_environment.h │ ├── mplfe_ut_options.cpp │ ├── mplfe_ut_options.h │ ├── mplfe_ut_regx.cpp │ ├── mplfe_ut_regx.h │ ├── mplfe_ut_regx_test.cpp │ ├── ops_ut_check.sh │ └── redirect_buffer.h ├── test ├── README.md ├── main.py ├── maple_test │ ├── __init__.py │ ├── compare.py │ ├── configs.py │ ├── main.py │ ├── maple_test.cfg │ ├── run.py │ ├── task.py │ ├── template.cfg │ ├── test.py │ └── utils.py └── testsuite │ ├── irbuild_test │ ├── I0001-mapleall-irbuild-edge-addf32 │ │ └── Main.mpl │ ├── I0002-mapleall-irbuild-edge-addi64 │ │ └── Main.mpl │ ├── I0003-mapleall-irbuild-edge-addi │ │ └── Main.mpl │ ├── I0004-mapleall-irbuild-edge-add │ │ └── Main.mpl │ ├── I0005-mapleall-irbuild-edge-arrayadd │ │ └── Main.mpl │ ├── I0006-mapleall-irbuild-edge-arrayinit │ │ └── Main.mpl │ ├── I0007-mapleall-irbuild-edge-attributes │ │ └── Main.mpl │ ├── I0008-mapleall-irbuild-edge-band │ │ └── Main.mpl │ ├── I0009-mapleall-irbuild-edge-binary │ │ └── Main.mpl │ ├── I0010-mapleall-irbuild-edge-bior │ │ └── Main.mpl │ ├── I0011-mapleall-irbuild-edge-bnot │ │ └── Main.mpl │ ├── I0012-mapleall-irbuild-edge-br │ │ └── Main.mpl │ ├── I0013-mapleall-irbuild-edge-callassigned │ │ └── Main.mpl │ ├── I0014-mapleall-irbuild-edge-ceil │ │ └── Main.mpl │ ├── I0015-mapleall-irbuild-edge-ciorcand │ │ └── Main.mpl │ ├── I0016-mapleall-irbuild-edge-classequal │ │ └── Main.mpl │ ├── I0017-mapleall-irbuild-edge-class_type │ │ └── Main.mpl │ ├── I0018-mapleall-irbuild-edge-constfloat │ │ └── Main.mpl │ ├── I0019-mapleall-irbuild-edge-constFoldTest │ │ └── Main.mpl │ ├── I0020-mapleall-irbuild-edge-cvtllutof32 │ │ └── Main.mpl │ ├── I0021-mapleall-irbuild-edge-cvtllutof64 │ │ └── Main.mpl │ ├── I0022-mapleall-irbuild-edge-depositbits1 │ │ └── Main.mpl │ ├── I0023-mapleall-irbuild-edge-DirectStorageAccess │ │ └── Main.mpl │ ├── I0024-mapleall-irbuild-edge-dowhile │ │ └── Main.mpl │ ├── I0025-mapleall-irbuild-edge-dupvardecl │ │ └── Main.mpl │ ├── I0026-mapleall-irbuild-edge-externfunc │ │ └── Main.mpl │ ├── I0027-mapleall-irbuild-edge-externvar │ │ └── Main.mpl │ ├── I0028-mapleall-irbuild-edge-extractbits │ │ └── Main.mpl │ ├── I0029-mapleall-irbuild-edge-fact │ │ └── Main.mpl │ ├── I0030-mapleall-irbuild-edge-farray │ │ └── Main.mpl │ ├── I0031-mapleall-irbuild-edge-fileinfo │ │ └── Main.mpl │ ├── I0032-mapleall-irbuild-edge-first │ │ └── Main.mpl │ ├── I0033-mapleall-irbuild-edge-floor │ │ └── Main.mpl │ ├── I0034-mapleall-irbuild-edge-foreachelem │ │ └── Main.mpl │ ├── I0035-mapleall-irbuild-edge-forwarddeclare │ │ └── Main.mpl │ ├── I0036-mapleall-irbuild-edge-funcptr │ │ └── Main.mpl │ ├── I0037-mapleall-irbuild-edge-generics │ │ └── Main.mpl │ ├── I0038-mapleall-irbuild-edge-global │ │ └── Main.mpl │ ├── I0039-mapleall-irbuild-edge-hello │ │ └── Main.mpl │ ├── I0040-mapleall-irbuild-edge-icallassigned │ │ └── Main.mpl │ ├── I0041-mapleall-irbuild-edge-if1 │ │ └── Main.mpl │ ├── I0042-mapleall-irbuild-edge-if │ │ └── Main.mpl │ ├── I0043-mapleall-irbuild-edge-if_then_else │ │ └── Main.mpl │ ├── I0044-mapleall-irbuild-edge-importpath │ │ └── Main.mpl │ ├── I0045-mapleall-irbuild-edge-indirect │ │ └── Main.mpl │ ├── I0046-mapleall-irbuild-edge-InDirectStorageAccess │ │ └── Main.mpl │ ├── I0047-mapleall-irbuild-edge-interface │ │ └── Main.mpl │ ├── I0048-mapleall-irbuild-edge-jarray │ │ └── Main.mpl │ ├── I0049-mapleall-irbuild-edge-just_ret │ │ └── Main.mpl │ ├── I0050-mapleall-irbuild-edge-land │ │ └── Main.mpl │ ├── I0051-mapleall-irbuild-edge-lior │ │ └── Main.mpl │ ├── I0052-mapleall-irbuild-edge-lnot │ │ └── Main.mpl │ ├── I0053-mapleall-irbuild-edge-loop │ │ └── Main.mpl │ ├── I0054-mapleall-irbuild-edge-malloc │ │ └── Main.mpl │ ├── I0055-mapleall-irbuild-edge-methods2 │ │ └── Main.mpl │ ├── I0056-mapleall-irbuild-edge-methods │ │ └── Main.mpl │ ├── I0057-mapleall-irbuild-edge-multiway │ │ └── Main.mpl │ ├── I0058-mapleall-irbuild-edge-multiwaystr │ │ └── Main.mpl │ ├── I0059-mapleall-irbuild-edge-neg │ │ └── Main.mpl │ ├── I0060-mapleall-irbuild-edge-parentfields │ │ └── Main.mpl │ ├── I0061-mapleall-irbuild-edge-polymorphiccallassigned │ │ └── Main.mpl │ ├── I0062-mapleall-irbuild-edge-pregs │ │ └── Main.mpl │ ├── I0063-mapleall-irbuild-edge-PrimTypes │ │ └── Main.mpl │ ├── I0064-mapleall-irbuild-edge-recip │ │ └── Main.mpl │ ├── I0065-mapleall-irbuild-edge-retype │ │ └── Main.mpl │ ├── I0066-mapleall-irbuild-edge-select │ │ └── Main.mpl │ ├── I0067-mapleall-irbuild-edge-specialchar │ │ └── Main.mpl │ ├── I0068-mapleall-irbuild-edge-sqrt │ │ └── Main.mpl │ ├── I0069-mapleall-irbuild-edge-struct2 │ │ └── Main.mpl │ ├── I0070-mapleall-irbuild-edge-structarrayinit │ │ └── Main.mpl │ ├── I0071-mapleall-irbuild-edge-structinit │ │ └── Main.mpl │ ├── I0072-mapleall-irbuild-edge-struct │ │ └── Main.mpl │ ├── I0073-mapleall-irbuild-edge-struct_type │ │ └── Main.mpl │ ├── I0074-mapleall-irbuild-edge-sub │ │ └── Main.mpl │ ├── I0075-mapleall-irbuild-edge-substructinit │ │ └── Main.mpl │ ├── I0076-mapleall-irbuild-edge-switch │ │ └── Main.mpl │ ├── I0077-mapleall-irbuild-edge-sync │ │ └── Main.mpl │ ├── I0078-mapleall-irbuild-edge-ternary │ │ └── Main.mpl │ ├── I0079-mapleall-irbuild-edge-testconst │ │ └── Main.mpl │ ├── I0081-mapleall-irbuild-edge-test_type │ │ └── Main.mpl │ ├── I0082-mapleall-irbuild-edge-twofunc │ │ └── Main.mpl │ ├── I0083-mapleall-irbuild-edge-tyconvertion │ │ └── Main.mpl │ ├── I0084-mapleall-irbuild-edge-unary │ │ └── Main.mpl │ ├── I0085-mapleall-irbuild-edge-virtualcallassigned │ │ └── Main.mpl │ ├── I0086-mapleall-irbuild-edge-virtualcall │ │ └── Main.mpl │ ├── I0087-mapleall-irbuild-edge-while │ │ └── Main.mpl │ └── test.cfg │ ├── maple.py │ ├── ouroboros │ ├── arrayboundary_test │ │ ├── RT0001-rt-arrayboundary-ABCOcatchArrayIndexOutOfBoundsException │ │ │ └── ABCOcatchArrayIndexOutOfBoundsException.java │ │ ├── RT0002-rt-arrayboundary-ABCOcatchIndexOutOfBoundsException │ │ │ └── ABCOcatchIndexOutOfBoundsException.java │ │ ├── RT0003-rt-arrayboundary-ABCOcatchStringIndexOutOfBoundsException │ │ │ └── ABCOcatchStringIndexOutOfBoundsException.java │ │ ├── RT0004-rt-arrayboundary-ABCOconstOperation │ │ │ └── ABCOconstOperation.java │ │ ├── RT0005-rt-arrayboundary-ABCOcustomClass │ │ │ └── ABCOcustomClass.java │ │ ├── RT0006-rt-arrayboundary-ABCOdoWhile │ │ │ └── ABCOdoWhile.java │ │ ├── RT0007-rt-arrayboundary-ABCOemptyArray │ │ │ └── ABCOemptyArray.java │ │ ├── RT0008-rt-arrayboundary-ABCOemptyString │ │ │ └── ABCOemptyString.java │ │ ├── RT0009-rt-arrayboundary-ABCOfor │ │ │ └── ABCOfor.java │ │ ├── RT0010-rt-arrayboundary-ABCOglobalArray │ │ │ └── ABCOglobalArray.java │ │ ├── RT0011-rt-arrayboundary-ABCOglobalIndex │ │ │ └── ABCOglobalIndex.java │ │ ├── RT0012-rt-arrayboundary-ABCOglobalString │ │ │ └── ABCOglobalString.java │ │ ├── RT0013-rt-arrayboundary-ABCOif │ │ │ └── ABCOif.java │ │ ├── RT0014-rt-arrayboundary-ABCOincreaseArray │ │ │ └── ABCOincreaseArray.java │ │ ├── RT0015-rt-arrayboundary-ABCOindexAssociation │ │ │ └── ABCOindexAssociation.java │ │ ├── RT0016-rt-arrayboundary-ABCOindexDoWhile │ │ │ └── ABCOindexDoWhile.java │ │ ├── RT0017-rt-arrayboundary-ABCOindexFor │ │ │ └── ABCOindexFor.java │ │ ├── RT0018-rt-arrayboundary-ABCOindexFromArrayFromParam │ │ │ └── ABCOindexFromArrayFromParam.java │ │ ├── RT0019-rt-arrayboundary-ABCOindexIf │ │ │ └── ABCOindexIf.java │ │ ├── RT0020-rt-arrayboundary-ABCOindexMutiLoop │ │ │ └── ABCOindexMutiLoop.java │ │ ├── RT0021-rt-arrayboundary-ABCOindexNesting │ │ │ └── ABCOindexNesting.java │ │ ├── RT0022-rt-arrayboundary-ABCOindexSwitch │ │ │ └── ABCOindexSwitch.java │ │ ├── RT0023-rt-arrayboundary-ABCOlength │ │ │ └── ABCOlength.java │ │ ├── RT0024-rt-arrayboundary-ABCOlistToArray │ │ │ └── ABCOlistToArray.java │ │ ├── RT0025-rt-arrayboundary-ABCOlocalArray │ │ │ └── ABCOlocalArray.java │ │ ├── RT0026-rt-arrayboundary-ABCOlocalIndex │ │ │ └── ABCOlocalIndex.java │ │ ├── RT0027-rt-arrayboundary-ABCOnewArraySize │ │ │ └── ABCOnewArraySize.java │ │ ├── RT0028-rt-arrayboundary-ABCOnormal │ │ │ └── ABCOnormal.java │ │ ├── RT0029-rt-arrayboundary-ABCOparamIndex │ │ │ └── ABCOparamIndex.java │ │ ├── RT0030-rt-arrayboundary-ABCOparam │ │ │ └── ABCOparam.java │ │ ├── RT0031-rt-arrayboundary-ABCOreflectArray │ │ │ └── ABCOreflectArray.java │ │ ├── RT0032-rt-arrayboundary-ABCOreturnArray │ │ │ └── ABCOreturnArray.java │ │ ├── RT0033-rt-arrayboundary-ABCOreturnIndex │ │ │ └── ABCOreturnIndex.java │ │ ├── RT0034-rt-arrayboundary-ABCOreturnString │ │ │ └── ABCOreturnString.java │ │ ├── RT0035-rt-arrayboundary-ABCOStringBuilderCatchEx │ │ │ └── ABCOStringBuilderCatchEx.java │ │ ├── RT0036-rt-arrayboundary-ABCOStringConstOperation │ │ │ └── ABCOStringConstOperation.java │ │ ├── RT0037-rt-arrayboundary-ABCOstringDoWhile │ │ │ └── ABCOstringDoWhile.java │ │ ├── RT0038-rt-arrayboundary-ABCOstringFor │ │ │ └── ABCOstringFor.java │ │ ├── RT0039-rt-arrayboundary-ABCOstringIf │ │ │ └── ABCOstringIf.java │ │ ├── RT0040-rt-arrayboundary-ABCOstringIndexNesting │ │ │ └── ABCOstringIndexNesting.java │ │ ├── RT0041-rt-arrayboundary-ABCOStringMaxValue │ │ │ └── ABCOStringMaxValue.java │ │ ├── RT0042-rt-arrayboundary-ABCOstringMutiLoop │ │ │ └── ABCOstringMutiLoop.java │ │ ├── RT0043-rt-arrayboundary-ABCOstringSwitch │ │ │ └── ABCOstringSwitch.java │ │ ├── RT0044-rt-arrayboundary-ABCOswitch │ │ │ └── ABCOswitch.java │ │ ├── RT0045-rt-arrayboundary-ABCOtryExtEh │ │ │ └── ABCOtryExtEh.java │ │ ├── RT0046-rt-arrayboundary-ABCOmaxValue │ │ │ └── ABCOmaxValue.java │ │ ├── RT0047-rt-arrayboundary-ABCOwhile │ │ │ └── ABCOwhile.java │ │ └── RT0048-rt-arrayboundary-ABCOwhileString │ │ │ └── ABCOwhileString.java │ ├── clinit_test │ │ ├── RT0001-rt-clinit-clinit_base_001 │ │ │ └── ClinitBase001.java │ │ ├── RT0002-rt-clinit-clinit_base_002 │ │ │ └── ClinitBase002.java │ │ ├── RT0003-rt-clinit-clinit_base_003 │ │ │ └── ClinitBase003.java │ │ ├── RT0004-rt-clinit-clinit_base_004 │ │ │ └── ClinitBase004.java │ │ ├── RT0005-rt-clinit-clinit_base_005 │ │ │ └── ClinitBase005.java │ │ ├── RT0006-rt-clinit-clinit_base_006 │ │ │ └── ClinitBase006.java │ │ ├── RT0008-rt-clinit-clinit_base_008 │ │ │ └── ClinitBase008.java │ │ ├── RT0009-rt-clinit-clinit_seq_001 │ │ │ └── ClinitSeq001.java │ │ ├── RT0010-rt-clinit-clinit_seq_002 │ │ │ └── ClinitSeq002.java │ │ ├── RT0011-rt-clinit-clinit_seq_003 │ │ │ └── ClinitSeq003.java │ │ ├── RT0012-rt-clinit-clinit_seq_004 │ │ │ └── ClinitSeq004.java │ │ └── RT0013-rt-clinit-clinit_seq_005 │ │ │ └── ClinitSeq005.java │ ├── eh_test │ │ ├── RT0023-rt-eh-NativeCatchExceptionTest │ │ │ ├── NativeCatchExceptionTest.java │ │ │ └── jniNativeCatchExceptionTest.cpp │ │ ├── RT0024-rt-eh-NativeCodeCheckExceptionTest │ │ │ ├── NativeCodeCheckExceptionTest.java │ │ │ └── jniNativeCodeCheckExceptionTest.cpp │ │ ├── RT0025-rt-eh-NativeNewExceptionTest │ │ │ ├── NativeNewExceptionTest.java │ │ │ └── jniNativeNewExceptionTest.cpp │ │ ├── RT0026-rt-eh-NativeTryCatchNewExceptionTest │ │ │ ├── NativeTryCatchNewExceptionTest.java │ │ │ └── jniNativeTryCatchNewExceptionTest.cpp │ │ ├── RT0027-rt-eh-NativeCodeCheckNewExceptionTest │ │ │ ├── NativeCodeCheckNewExceptionTest.java │ │ │ └── jniNativeCodeCheckNewExceptionTest.cpp │ │ ├── RT0028-rt-eh-NativeClearExceptionTest │ │ │ ├── NativeClearExceptionTest.java │ │ │ └── jniNativeClearExceptionTest.cpp │ │ ├── RT0029-rt-eh-NativeCodeCatchThrowNewExceptionTest │ │ │ ├── NativeCodeCatchThrowNewExceptionTest.java │ │ │ └── jniNativeCodeCatchThrowNewExceptionTest.cpp │ │ ├── RT0030-rt-eh-NativeCheckFatalErrorExceptionTest │ │ │ ├── NativeCheckFatalErrorExceptionTest.java │ │ │ └── jniNativeCheckFatalErrorExceptionTest.cpp │ │ ├── RT0032-rt-eh-TryFinallyExceptionTest │ │ │ └── TryFinallyExceptionTest.java │ │ ├── RT0033-rt-eh-TryCatchExceptionTest │ │ │ └── TryCatchExceptionTest.java │ │ ├── RT0034-rt-eh-TryMultiCatchExceptionTest │ │ │ └── TryMultiCatchExceptionTest.java │ │ ├── RT0035-rt-eh-TryMultiCatchMatchFirstExceptionTest │ │ │ └── TryMultiCatchMatchFirstExceptionTest.java │ │ ├── RT0036-rt-eh-TryCatchPipelineExceptionTest │ │ │ └── TryCatchPipelineExceptionTest.java │ │ ├── RT0037-rt-eh-TryMultiCatchFinallyExceptionTest │ │ │ └── TryMultiCatchFinallyExceptionTest.java │ │ ├── RT0038-rt-eh-TryCatchResourceExceptionTest │ │ │ └── TryCatchResourceExceptionTest.java │ │ ├── RT0039-rt-eh-TryCatchThrowExceptionTest │ │ │ └── TryCatchThrowExceptionTest.java │ │ ├── RT0040-rt-eh-TryExceptionFinallyExceptionTest │ │ │ └── TryExceptionFinallyExceptionTest.java │ │ ├── RT0041-rt-eh-TryTryThrowExceptionTest │ │ │ └── TryTryThrowExceptionTest.java │ │ ├── RT0042-rt-eh-TryTryCatchExceptionTest │ │ │ └── TryTryCatchExceptionTest.java │ │ ├── RT0043-rt-eh-TryCatchTryExceptionTest │ │ │ └── TryCatchTryExceptionTest.java │ │ ├── RT0044-rt-eh-DoubleTryCatchFinallyExceptionTest │ │ │ └── DoubleTryCatchFinallyExceptionTest.java │ │ ├── RT0045-rt-eh-TryCatchTryCatchFinallyExceptionTest │ │ │ └── TryCatchTryCatchFinallyExceptionTest.java │ │ ├── RT0046-rt-eh-TryCatchTryCatchExceptionFinallyTest │ │ │ └── TryCatchTryCatchExceptionFinallyTest.java │ │ ├── RT0047-rt-eh-CatchThrowNewExceptionTest │ │ │ └── CatchThrowNewExceptionTest.java │ │ ├── RT0048-rt-eh-CatchTryCatchNewExceptionTest │ │ │ └── CatchTryCatchNewExceptionTest.java │ │ ├── RT0049-rt-eh-CatchTryThrowNewExceptionTest │ │ │ └── CatchTryThrowNewExceptionTest.java │ │ ├── RT0050-rt-eh-FinallyThrowExceptionTest │ │ │ └── FinallyThrowExceptionTest.java │ │ ├── RT0051-rt-eh-FinallyTryCatchExceptionTest │ │ │ └── FinallyTryCatchExceptionTest.java │ │ ├── RT0052-rt-eh-FinallyTryThrowExceptionTest │ │ │ └── FinallyTryThrowExceptionTest.java │ │ ├── RT0053-rt-eh-TryResourceStartThrowExceptionTest │ │ │ └── TryResourceStartThrowExceptionTest.java │ │ ├── RT0054-rt-eh-TryResourceCloseThrowExceptionTest │ │ │ └── TryResourceCloseThrowExceptionTest.java │ │ ├── RT0055-rt-eh-TryResourceStartAndCloseExceptionTest │ │ │ └── TryResourceStartAndCloseExceptionTest.java │ │ ├── RT0066-rt-eh-JvmArrayIndexOutOfBoundsExceptionTest │ │ │ └── JvmArrayIndexOutOfBoundsExceptionTest.java │ │ ├── RT0067-rt-eh-JvmStaticExceptionInInitializerErrorTest │ │ │ └── JvmStaticExceptionInInitializerErrorTest.java │ │ ├── RT0073-rt-eh-MultiTryNoExceptionTest │ │ │ └── MultiTryNoExceptionTest.java │ │ ├── RT0074-rt-eh-TryCatchReturnExceptionTest │ │ │ └── TryCatchReturnExceptionTest.java │ │ ├── RT0075-rt-eh-TryReturnValueExceptionTest │ │ │ └── TryReturnValueExceptionTest.java │ │ ├── RT0076-rt-eh-TryCatchReturnValueExceptionTest │ │ │ └── TryCatchReturnValueExceptionTest.java │ │ ├── RT0077-rt-eh-ExcpReturn04140 │ │ │ └── ExcpReturn04140.java │ │ ├── RT0078-rt-eh-ExcpReturn04150 │ │ │ └── ExcpReturn04150.java │ │ ├── RT0079-rt-eh-ExcpReturn04160 │ │ │ └── ExcpReturn04160.java │ │ ├── RT0516-rt-eh-AccessibleObjectGetAnnotationsByTypeNullPointerExceptionTest │ │ │ └── AccessibleObjectGetAnnotationsByTypeNullPointerExceptionTest.java │ │ ├── RT0517-rt-eh-AccessibleObjectGetDeclaredAnnotationExceptionTest │ │ │ └── AccessibleObjectGetDeclaredAnnotationExceptionTest.java │ │ ├── RT0518-rt-eh-AccessibleObjectGetDeclaredAnnotationsByTypeExceptionTest │ │ │ └── AccessibleObjectGetDeclaredAnnotationsByTypeExceptionTest.java │ │ ├── RT0519-rt-eh-CharacterCodePointCountIndexOutOfBoundsExceptionTest │ │ │ └── CharacterCodePointCountIndexOutOfBoundsExceptionTest.java │ │ ├── RT0520-rt-eh-CharactercodePointCountNullPointerException │ │ │ └── CharactercodePointCountNullPointerException.java │ │ ├── RT0521-rt-eh-CharacteroffsetByCodePointsIndexOutOfBoundsException │ │ │ └── CharacteroffsetByCodePointsIndexOutOfBoundsException.java │ │ ├── RT0522-rt-eh-CharacteroffsetByCodePointsNullPointerException │ │ │ └── CharacteroffsetByCodePointsNullPointerException.java │ │ ├── RT0523-rt-eh-ClassasSubclassClassCastException │ │ │ └── ClassasSubclassClassCastException.java │ │ ├── RT0524-rt-eh-ClasscastClassCastException │ │ │ └── ClasscastClassCastException.java │ │ ├── RT0525-rt-eh-ClassforName1ParExceptionInInitializerError │ │ │ └── ClassforName1ParExceptionInInitializerError.java │ │ ├── RT0526-rt-eh-ClassforNameExceptionInInitializerError │ │ │ └── ClassforNameExceptionInInitializerError.java │ │ ├── RT0527-rt-eh-ClassgAnnotationsByTypeNullPointerException │ │ │ └── ClassgAnnotationsByTypeNullPointerException.java │ │ ├── RT0528-rt-eh-ClassgetDeclaredAnnotationNullPointerException │ │ │ └── ClassgetDeclaredAnnotationNullPointerException.java │ │ ├── RT0529-rt-eh-ClassgetDeclaredFieldNoSuchFieldException │ │ │ └── ClassgetDeclaredFieldNoSuchFieldException.java │ │ ├── RT0530-rt-eh-ClassgetDeclaredFieldNullPointerException │ │ │ └── ClassgetDeclaredFieldNullPointerException.java │ │ ├── RT0531-rt-eh-ConstructorgAnnotationNullPointerException │ │ │ └── ConstructorgAnnotationNullPointerException.java │ │ ├── RT0532-rt-eh-ConstructornewInstanceExceptionInInitializerError │ │ │ └── ConstructornewInstanceExceptionInInitializerError.java │ │ ├── RT0533-rt-eh-FieldgetAnnotationNullPointerException │ │ │ └── FieldgetAnnotationNullPointerException.java │ │ ├── RT0534-rt-eh-FieldgetAnnotationsByTypeNullPointerException │ │ │ └── FieldgetAnnotationsByTypeNullPointerException.java │ │ ├── RT0535-rt-eh-FieldgetByteExceptionInInitializerError │ │ │ └── FieldgetByteExceptionInInitializerError.java │ │ ├── RT0536-rt-eh-FieldgetCharExceptionInInitializerError │ │ │ └── FieldgetCharExceptionInInitializerError.java │ │ ├── RT0537-rt-eh-FieldgetDoubleExceptionInInitializerError │ │ │ └── FieldgetDoubleExceptionInInitializerError.java │ │ ├── RT0538-rt-eh-FieldgetExceptionInInitializerError │ │ │ └── FieldgetExceptionInInitializerError.java │ │ ├── RT0539-rt-eh-FieldgetFloatExceptionInInitializerError │ │ │ └── FieldgetFloatExceptionInInitializerError.java │ │ ├── RT0541-rt-eh-FieldGetIntExceptionInInitializerErrorTest │ │ │ └── FieldGetIntExceptionInInitializerErrorTest.java │ │ ├── RT0542-rt-eh-FieldGetLongExceptionInInitializerErrorTest │ │ │ └── FieldGetLongExceptionInInitializerErrorTest.java │ │ ├── RT0543-rt-eh-FieldGetShortExceptionInInitializerErrorTest │ │ │ └── FieldGetShortExceptionInInitializerErrorTest.java │ │ ├── RT0544-rt-eh-FieldSetBooleanExceptionInInitializerErrorTest │ │ │ └── FieldSetBooleanExceptionInInitializerErrorTest.java │ │ ├── RT0545-rt-eh-FieldSetByteExceptionInInitializerErrorTest │ │ │ └── FieldSetByteExceptionInInitializerErrorTest.java │ │ ├── RT0546-rt-eh-FieldSetCharExceptionInInitializerErrorTest │ │ │ └── FieldSetCharExceptionInInitializerErrorTest.java │ │ ├── RT0547-rt-eh-FieldSetDoubleExceptionInInitializerErrorTest │ │ │ └── FieldSetDoubleExceptionInInitializerErrorTest.java │ │ ├── RT0548-rt-eh-FieldsetExceptionInInitializerErrorTest │ │ │ └── FieldSetExceptionInInitializerErrorTest.java │ │ ├── RT0549-rt-eh-FieldSetFloatExceptionInInitializerErrorTest │ │ │ └── FieldSetFloatExceptionInInitializerErrorTest.java │ │ ├── RT0550-rt-eh-FieldSetIntExceptionTest │ │ │ └── FieldSetIntExceptionTest.java │ │ ├── RT0551-rt-eh-FieldSetLongExceptionTest │ │ │ └── FieldSetLongExceptionTest.java │ │ ├── RT0552-rt-eh-FieldSetShortExceptionTest │ │ │ └── FieldSetShortExceptionTest.java │ │ ├── RT0553-rt-eh-MethodGetAnnotationExceptionTest │ │ │ └── MethodGetAnnotationExceptionTest.java │ │ ├── RT0555-rt-eh-MethodInvokeExceptionInInitializerErrorTest │ │ │ └── MethodInvokeExceptionInInitializerErrorTest.java │ │ ├── RT0556-rt-eh-ParameterGetAnnotationNullPointerExceptionTest │ │ │ └── ParameterGetAnnotationNullPointerExceptionTest.java │ │ ├── RT0557-rt-eh-ParameterGetAnnotationsByTypeNullPointerExceptionTest │ │ │ └── ParameterGetAnnotationsByTypeNullPointerExceptionTest.java │ │ ├── RT0558-rt-eh-ParameterGetDeclaredAnnotationNullPointerExceptionTest │ │ │ └── ParameterGetDeclaredAnnotationNullPointerExceptionTest.java │ │ ├── RT0559-rt-eh-ParameterGetDeclaredAnnotationsByTypeExceptionTest │ │ │ └── ParameterGetDeclaredAnnotationsByTypeExceptionTest.java │ │ ├── RT0560-rt-eh-ThrowableAddSuppressedExceptionTest │ │ │ └── ThrowableAddSuppressedExceptionTest.java │ │ ├── RT0561-rt-eh-ThrowableAddSuppressedNullPointerExceptionTest │ │ │ └── ThrowableAddSuppressedNullPointerExceptionTest.java │ │ ├── RT0817-rt-mrtUT-MethodInvokeExceptionTest │ │ │ └── MethodInvokeExceptionTest.java │ │ ├── RT0904-rt-fuzzapi-MethodInvokeObjectObjectsTest │ │ │ └── MethodInvokeObjectObjectsTest.java │ │ ├── RT1075-rt-EH-MethodInvokeInvocationTargetExceptionTest │ │ │ └── MethodInvokeInvocationTargetExceptionTest.java │ │ ├── issue-RT0065-rt-eh-UninitializedExNullPointerExceptionTest │ │ │ └── UninitializedExNullPointerExceptionTest.java │ │ └── issue-RT0068-rt-eh-JvmInitializeOutOfMemoryErrorTest │ │ │ └── JvmInitializeOutOfMemoryErrorTest.java │ ├── fuzzapi_test │ │ ├── RT0001-rt-fuzzapi-PipedReaderEH │ │ │ └── Message125004.java │ │ ├── RT0002-rt-fuzzapi-EHOrder │ │ │ └── Message011706.java │ │ ├── RT0003-rt-fuzzapi-noStartThreadInfo │ │ │ └── ThreadcountStackFramesTest.java │ │ ├── RT0004-rt-fuzzapi-stackframeless │ │ │ └── Message021404.java │ │ └── issue-RT0901-rt-fuzzapi-Message61004-subStringOOM │ │ │ └── Message61004.java │ ├── memory_management │ │ ├── Annotation │ │ │ ├── RC0380-rc-Annotation-RCWeakRefTest │ │ │ │ └── RCWeakRefTest.java │ │ │ ├── RC0381-rc-Annotation-RCWeakRefTest2 │ │ │ │ └── RCWeakRefTest2.java │ │ │ ├── RC0383-rc-Annotation-RCWeakRefTest4 │ │ │ │ └── RCWeakRefTest4.java │ │ │ ├── RC0384-rc-Annotation-RCWeakRefThreadTest │ │ │ │ └── RCWeakRefThreadTest.java │ │ │ ├── RC0386-rc-Annotation-RCUnownedRefTest2 │ │ │ │ └── RCUnownedRefTest2.java │ │ │ ├── RC0387-rc-Annotation-RCUnownedRefUnCycle │ │ │ │ └── RCUnownedRefUnCycle.java │ │ │ ├── RC0389-rc-Annotation-RCUnownedRefUncycleThread │ │ │ │ └── RCUnownedRefUncycleThread.java │ │ │ ├── RC0391-rc-Annotation-RCAnnotationThread01 │ │ │ │ └── RCAnnotationThread01.java │ │ │ ├── RC0392-rc-Annotation-RCAnnotationThread02 │ │ │ │ └── RCAnnotationThread02.java │ │ │ ├── RC0393-rc-Annotation-RCAnnotationThread03 │ │ │ │ └── RCAnnotationThread03.java │ │ │ ├── RC0394-rc-Annotation-RCAnnotationThread04 │ │ │ │ └── RCAnnotationThread04.java │ │ │ ├── RC0395-rc-Annotation-RCAnnotationThread05 │ │ │ │ └── RCAnnotationThread05.java │ │ │ ├── RC0396-rc-Annotation-RCAnnotationOneCycle │ │ │ │ └── RCAnnotationOneCycle.java │ │ │ ├── RC0397-rc-Annotation-RCAnnotationOneCycleThread │ │ │ │ └── RCAnnotationOneCycleThread.java │ │ │ ├── RC0398-rc-Annotation-RCAnnotationTwoCycle │ │ │ │ └── RCAnnotationTwoCycle.java │ │ │ ├── RC0399-rc-Annotation-RCAnnotationTwoCycle2 │ │ │ │ └── RCAnnotationTwoCycle2.java │ │ │ ├── RC0400-rc-Annotation-RCAnnotationTwoCycleThread │ │ │ │ └── RCAnnotationTwoCycleThread.java │ │ │ ├── RC0401-rc-Annotation-RCAnnotationTwoCycleThread2 │ │ │ │ └── RCAnnotationTwoCycleThread2.java │ │ │ ├── RC0402-rc-Annotation-RCAnnotationMultiCycle │ │ │ │ └── RCAnnotationMultiCycle.java │ │ │ ├── RC0403-rc-Annotation-RCAnnotationMultiCycle2 │ │ │ │ └── RCAnnotationMultiCycle2.java │ │ │ ├── RC0404-rc-Annotation-RCAnnotationMultiCycleThread │ │ │ │ └── RCAnnotationMultiCycleThread.java │ │ │ ├── RC0405-rc-Annotation-RCAnnotationMultiCycleThread2 │ │ │ │ └── RCAnnotationMultiCycleThread2.java │ │ │ ├── RC0419-rc-Annotation-RCUnownedLocalTest │ │ │ │ └── RCUnownedLocalTest.java │ │ │ ├── RC0420-rc-Annotation-RCUnownedLocalThreadTest │ │ │ │ └── RCUnownedLocalThreadTest.java │ │ │ ├── RC0421-rc-Annotation-RCUnownedOuterTest │ │ │ │ └── RCUnownedOuterTest.java │ │ │ ├── RC0428-rc-Annotation-RCMixThreadTest │ │ │ │ └── RCMixThreadTest.java │ │ │ ├── issue-RC0388-rc-Annotation-RCUnownedRefUnCycle02 │ │ │ │ └── RCUnownedRefUncycle02.java │ │ │ └── issue-RC0390-rc-Annotation-RCUnownedRefUncycleThread2 │ │ │ │ └── RCUnownedRefUncycleThread2.java │ │ ├── ArrayOptimization │ │ │ ├── RC0366-rc-ArrayOptimization-RC_Array_01 │ │ │ │ └── RC_Array_01.java │ │ │ ├── RC0367-rc-ArrayOptimization-RC_Array_02 │ │ │ │ └── RC_Array_02.java │ │ │ ├── RC0368-rc-ArrayOptimization-RC_Array_03 │ │ │ │ └── RC_Array_03.java │ │ │ ├── RC0369-rc-ArrayOptimization-RC_Array_04 │ │ │ │ └── RC_Array_04.java │ │ │ ├── RC0370-rc-ArrayOptimization-RC_Array_05 │ │ │ │ └── RC_Array_05.java │ │ │ ├── RC0371-rc-ArrayOptimization-RC_Array_06 │ │ │ │ └── RC_Array_06.java │ │ │ ├── RC0372-rc-ArrayOptimization-RC_Array_07 │ │ │ │ └── RC_Array_07.java │ │ │ ├── RC0373-rc-ArrayOptimization-RC_Array_08 │ │ │ │ └── RC_Array_08.java │ │ │ └── RC0374-rc-ArrayOptimization-RC_Array_09 │ │ │ │ └── RC_Array_09.java │ │ ├── BindingMethod │ │ │ ├── RC0468-rc-BindingMethod-ArrayCloneTest │ │ │ │ └── ArrayCloneTest.java │ │ │ ├── RC0469-rc-BindingMethod-ArrayCloneTest02 │ │ │ │ └── ArrayCloneTest02.java │ │ │ ├── RC0470-rc-BindingMethod-ArrayCopyTest │ │ │ │ └── ArrayCopyTest.java │ │ │ ├── RC0471-rc-BindingMethod-UnsafeTest01 │ │ │ │ └── UnsafeTest01.java │ │ │ ├── RC0472-rc-BindingMethod-UnsafeTest02 │ │ │ │ └── UnsafeTest02.java │ │ │ ├── RC0473-rc-BindingMethod-UnsafeTest03 │ │ │ │ └── UnsafeTest03.java │ │ │ ├── RC0474-rc-BindingMethod-UnsafeTest04 │ │ │ │ └── UnsafeTest04.java │ │ │ ├── RC0475-rc-BindingMethod-UnsafeTest05 │ │ │ │ └── UnsafeTest05.java │ │ │ └── RC0476-rc-BindingMethod-UnsafeTest06 │ │ │ │ └── UnsafeTest06.java │ │ ├── DTS │ │ │ ├── RC0406-rc-DTS-stringIntern │ │ │ │ └── stringIntern.java │ │ │ ├── RC0407-rc-DTS-stackAllocField │ │ │ │ └── stackAllocField.java │ │ │ ├── RC0408-rc-DTS-OOMtest │ │ │ │ └── OOMtest.java │ │ │ └── RC0409-rc-DTS-Ex_eight_arguments │ │ │ │ └── Ex_eight_arguments.java │ │ ├── Function │ │ │ ├── RC0001-rc-function-Cycle_a_00180 │ │ │ │ └── Cycle_a_00180.java │ │ │ ├── RC0002-rc-function-Cycle_a_00190 │ │ │ │ └── Cycle_a_00190.java │ │ │ ├── RC0003-rc-function-Cycle_a_00200 │ │ │ │ └── Cycle_a_00200.java │ │ │ ├── RC0004-rc-function-Cycle_a_00210 │ │ │ │ └── Cycle_a_00210.java │ │ │ ├── RC0005-rc-function-Cycle_a_00220 │ │ │ │ └── Cycle_a_00220.java │ │ │ ├── RC0006-rc-function-Cycle_a_00230 │ │ │ │ └── Cycle_a_00230.java │ │ │ ├── RC0007-rc-function-Cycle_a_00240 │ │ │ │ └── Cycle_a_00240.java │ │ │ ├── RC0008-rc-function-Cycle_a_00250 │ │ │ │ └── Cycle_a_00250.java │ │ │ ├── RC0009-rc-function-Cycle_a_00260 │ │ │ │ └── Cycle_a_00260.java │ │ │ ├── RC0010-rc-function-Cycle_a_00270 │ │ │ │ └── Cycle_a_00270.java │ │ │ ├── RC0011-rc-function-Cycle_a_00280 │ │ │ │ └── Cycle_a_00280.java │ │ │ ├── RC0012-rc-function-Cycle_a_00290 │ │ │ │ └── Cycle_a_00290.java │ │ │ ├── RC0013-rc-function-Cycle_a_00300 │ │ │ │ └── Cycle_a_00300.java │ │ │ ├── RC0014-rc-function-Cycle_a_00310 │ │ │ │ └── Cycle_a_00310.java │ │ │ ├── RC0015-rc-function-Cycle_a_00320 │ │ │ │ └── Cycle_a_00320.java │ │ │ ├── RC0016-rc-function-Cycle_a_00330 │ │ │ │ └── Cycle_a_00330.java │ │ │ ├── RC0017-rc-function-Cycle_a_00340 │ │ │ │ └── Cycle_a_00340.java │ │ │ ├── RC0018-rc-function-Cycle_a_00350 │ │ │ │ └── Cycle_a_00350.java │ │ │ ├── RC0019-rc-function-Cycle_a_00360 │ │ │ │ └── Cycle_a_00360.java │ │ │ ├── RC0020-rc-function-Cycle_a_00370 │ │ │ │ └── Cycle_a_00370.java │ │ │ ├── RC0021-rc-function-Cycle_a_00380 │ │ │ │ └── Cycle_a_00380.java │ │ │ ├── RC0022-rc-function-Cycle_a_00390 │ │ │ │ └── Cycle_a_00390.java │ │ │ ├── RC0023-rc-function-Cycle_a_00400 │ │ │ │ └── Cycle_a_00400.java │ │ │ ├── RC0024-rc-function-Cycle_a_00410 │ │ │ │ └── Cycle_a_00410.java │ │ │ ├── RC0025-rc-function-Cycle_a_00420 │ │ │ │ └── Cycle_a_00420.java │ │ │ ├── RC0026-rc-function-Cycle_a_00430 │ │ │ │ └── Cycle_a_00430.java │ │ │ ├── RC0027-rc-function-Cycle_a_00440 │ │ │ │ └── Cycle_a_00440.java │ │ │ ├── RC0028-rc-function-Cycle_a_00450 │ │ │ │ └── Cycle_a_00450.java │ │ │ ├── RC0029-rc-function-Cycle_a_00460 │ │ │ │ └── Cycle_a_00460.java │ │ │ ├── RC0030-rc-function-Cycle_a_00470 │ │ │ │ └── Cycle_a_00470.java │ │ │ ├── RC0031-rc-function-Cycle_a_00480 │ │ │ │ └── Cycle_a_00480.java │ │ │ ├── RC0032-rc-function-Cycle_a_00490 │ │ │ │ └── Cycle_a_00490.java │ │ │ ├── RC0033-rc-function-Cycle_a_00500 │ │ │ │ └── Cycle_a_00500.java │ │ │ ├── RC0034-rc-function-Cycle_a_10010 │ │ │ │ └── Cycle_a_10010.java │ │ │ ├── RC0035-rc-function-Cycle_a_10020 │ │ │ │ └── Cycle_a_10020.java │ │ │ ├── RC0036-rc-function-Cycle_B_1_00010 │ │ │ │ └── Cycle_B_1_00010.java │ │ │ ├── RC0037-rc-function-Cycle_B_1_00020 │ │ │ │ └── Cycle_B_1_00020.java │ │ │ ├── RC0038-rc-function-Cycle_B_1_00030 │ │ │ │ └── Cycle_B_1_00030.java │ │ │ ├── RC0039-rc-function-Cycle_B_1_00040 │ │ │ │ └── Cycle_B_1_00040.java │ │ │ ├── RC0040-rc-function-Cycle_B_1_00050 │ │ │ │ └── Cycle_B_1_00050.java │ │ │ ├── RC0041-rc-function-Cycle_B_1_00060 │ │ │ │ └── Cycle_B_1_00060.java │ │ │ ├── RC0042-rc-function-Cycle_B_1_00070 │ │ │ │ └── Cycle_B_1_00070.java │ │ │ ├── RC0043-rc-function-Cycle_B_1_00080 │ │ │ │ └── Cycle_B_1_00080.java │ │ │ ├── RC0044-rc-function-Cycle_B_1_00090 │ │ │ │ └── Cycle_B_1_00090.java │ │ │ ├── RC0045-rc-function-Cycle_B_1_00100 │ │ │ │ └── Cycle_B_1_00100.java │ │ │ ├── RC0046-rc-function-Cycle_B_1_00110 │ │ │ │ └── Cycle_B_1_00110.java │ │ │ ├── RC0047-rc-function-Cycle_B_1_00120 │ │ │ │ └── Cycle_B_1_00120.java │ │ │ ├── RC0048-rc-function-Cycle_B_1_00130 │ │ │ │ └── Cycle_B_1_00130.java │ │ │ ├── RC0049-rc-function-Cycle_B_1_00140 │ │ │ │ └── Cycle_B_1_00140.java │ │ │ ├── RC0050-rc-function-Cycle_B_1_00150 │ │ │ │ └── Cycle_B_1_00150.java │ │ │ ├── RC0051-rc-function-Cycle_B_1_00160 │ │ │ │ └── Cycle_B_1_00160.java │ │ │ ├── RC0052-rc-function-Cycle_B_1_00170 │ │ │ │ └── Cycle_B_1_00170.java │ │ │ ├── RC0053-rc-function-Cycle_B_1_00180 │ │ │ │ └── Cycle_B_1_00180.java │ │ │ ├── RC0054-rc-function-Cycle_B_1_00190 │ │ │ │ └── Cycle_B_1_00190.java │ │ │ ├── RC0055-rc-function-Cycle_B_1_00200 │ │ │ │ └── Cycle_B_1_00200.java │ │ │ ├── RC0056-rc-function-Cycle_B_1_10010 │ │ │ │ └── Cycle_B_1_10010.java │ │ │ ├── RC0057-rc-function-Cycle_B_1_10020 │ │ │ │ └── Cycle_B_1_10020.java │ │ │ ├── RC0058-rc-function-Cycle_B_2_00010 │ │ │ │ └── Cycle_B_2_00010.java │ │ │ ├── RC0059-rc-function-Cycle_B_2_00020 │ │ │ │ └── Cycle_B_2_00020.java │ │ │ ├── RC0060-rc-function-Cycle_B_2_00030 │ │ │ │ └── Cycle_B_2_00030.java │ │ │ ├── RC0061-rc-function-Cycle_B_2_00040 │ │ │ │ └── Cycle_B_2_00040.java │ │ │ ├── RC0062-rc-function-Cycle_B_2_00050 │ │ │ │ └── Cycle_B_2_00050.java │ │ │ ├── RC0063-rc-function-Cycle_B_2_00060 │ │ │ │ └── Cycle_B_2_00060.java │ │ │ ├── RC0064-rc-function-Cycle_B_2_00070 │ │ │ │ └── Cycle_B_2_00070.java │ │ │ ├── RC0065-rc-function-Cycle_B_2_00080 │ │ │ │ └── Cycle_B_2_00080.java │ │ │ ├── RC0066-rc-function-Cycle_B_2_00090 │ │ │ │ └── Cycle_B_2_00090.java │ │ │ ├── RC0067-rc-function-Cycle_B_2_00100 │ │ │ │ └── Cycle_B_2_00100.java │ │ │ ├── RC0068-rc-function-Cycle_B_2_00110 │ │ │ │ └── Cycle_B_2_00110.java │ │ │ ├── RC0069-rc-function-Cycle_B_2_00120 │ │ │ │ └── Cycle_B_2_00120.java │ │ │ ├── RC0070-rc-function-Cycle_B_2_00130 │ │ │ │ └── Cycle_B_2_00130.java │ │ │ ├── RC0071-rc-function-Cycle_B_2_00140 │ │ │ │ └── Cycle_B_2_00140.java │ │ │ ├── RC0072-rc-function-Cycle_B_2_00150 │ │ │ │ └── Cycle_B_2_00150.java │ │ │ ├── RC0073-rc-function-Cycle_B_2_00160 │ │ │ │ └── Cycle_B_2_00160.java │ │ │ ├── RC0074-rc-function-Cycle_B_2_00170 │ │ │ │ └── Cycle_B_2_00170.java │ │ │ ├── RC0075-rc-function-Cycle_B_2_00180 │ │ │ │ └── Cycle_B_2_00180.java │ │ │ ├── RC0076-rc-function-Cycle_B_2_00190 │ │ │ │ └── Cycle_B_2_00190.java │ │ │ ├── RC0077-rc-function-Cycle_B_2_00200 │ │ │ │ └── Cycle_B_2_00200.java │ │ │ ├── RC0078-rc-function-Cycle_B_2_00210 │ │ │ │ └── Cycle_B_2_00210.java │ │ │ ├── RC0079-rc-function-Cycle_B_2_00220 │ │ │ │ └── Cycle_B_2_00220.java │ │ │ ├── RC0080-rc-function-Cycle_B_2_00230 │ │ │ │ └── Cycle_B_2_00230.java │ │ │ ├── RC0081-rc-function-Cycle_B_2_00240 │ │ │ │ └── Cycle_B_2_00240.java │ │ │ ├── RC0082-rc-function-Nocycle_a_00010 │ │ │ │ └── Nocycle_a_00010.java │ │ │ ├── RC0083-rc-function-Nocycle_a_00020 │ │ │ │ └── Nocycle_a_00020.java │ │ │ ├── RC0084-rc-function-Nocycle_a_00030 │ │ │ │ └── Nocycle_a_00030.java │ │ │ ├── RC0085-rc-function-Nocycle_a_00040 │ │ │ │ └── Nocycle_a_00040.java │ │ │ ├── RC0086-rc-function-Nocycle_a_00050 │ │ │ │ └── Nocycle_a_00050.java │ │ │ ├── RC0087-rc-function-Nocycle_a_00060 │ │ │ │ └── Nocycle_a_00060.java │ │ │ ├── RC0088-rc-function-Nocycle_a_00070 │ │ │ │ └── Nocycle_a_00070.java │ │ │ ├── RC0089-rc-function-Nocycle_a_00080 │ │ │ │ └── Nocycle_a_00080.java │ │ │ ├── RC0090-rc-function-Nocycle_a_00090 │ │ │ │ └── Nocycle_a_00090.java │ │ │ ├── RC0091-rc-function-Nocycle_a_00100 │ │ │ │ └── Nocycle_a_00100.java │ │ │ ├── RC0092-rc-function-Nocycle_a_00110 │ │ │ │ └── Nocycle_a_00110.java │ │ │ ├── RC0093-rc-function-Nocycle_a_00120 │ │ │ │ └── Nocycle_a_00120.java │ │ │ ├── RC0094-rc-function-Nocycle_a_00130 │ │ │ │ └── Nocycle_a_00130.java │ │ │ ├── RC0095-rc-function-Nocycle_a_00140 │ │ │ │ └── Nocycle_a_00140.java │ │ │ ├── RC0096-rc-function-Nocycle_a_00150 │ │ │ │ └── Nocycle_a_00150.java │ │ │ ├── RC0097-rc-function-Nocycle_a_00160 │ │ │ │ └── Nocycle_a_00160.java │ │ │ ├── RC0098-rc-function-Nocycle_a_00170 │ │ │ │ └── Nocycle_a_00170.java │ │ │ ├── RC0099-rc-function-Nocycle_a_00180 │ │ │ │ └── Nocycle_a_00180.java │ │ │ ├── RC0100-rc-function-Nocycle_a_2_00010 │ │ │ │ └── Nocycle_a_2_00010.java │ │ │ ├── RC0101-rc-function-Nocycle_a_2_00020 │ │ │ │ └── Nocycle_a_2_00020.java │ │ │ ├── RC0102-rc-function-RC_basic │ │ │ │ └── RC_basic.java │ │ │ ├── RC0103-rc-function-RC_eh_01 │ │ │ │ └── RC_eh_01.java │ │ │ ├── RC0104-rc-function-RC_Finalize_01 │ │ │ │ └── RC_Finalize_01.java │ │ │ ├── RC0105-rc-function-RC_flow │ │ │ │ └── RC_flow.java │ │ │ ├── RC0106-rc-function-RC_multest │ │ │ │ └── RC_multest.java │ │ │ ├── RC0107-rc-function-RC_Dec-Cycle_aDec_00010 │ │ │ │ └── Cycle_aDec_00010.java │ │ │ ├── RC0108-rc-function-RC_Dec-Cycle_aDec_00020 │ │ │ │ └── Cycle_aDec_00020.java │ │ │ ├── RC0109-rc-function-RC_Dec-Cycle_BDec_00010 │ │ │ │ └── Cycle_BDec_00010.java │ │ │ ├── RC0110-rc-function-RC_Dec-Cycle_BDec_00020 │ │ │ │ └── Cycle_BDec_00020.java │ │ │ ├── RC0111-rc-function-RC_Dec-Cycle_BDec_00030 │ │ │ │ └── Cycle_BDec_00030.java │ │ │ ├── RC0112-rc-function-RC_Dec-Cycle_BDec_00040 │ │ │ │ └── Cycle_BDec_00040.java │ │ │ ├── RC0113-rc-function-RC_Dec-Cycle_BDec_00050 │ │ │ │ └── Cycle_BDec_00050.java │ │ │ ├── RC0114-rc-function-RC_Dec-Nocycle_aDec_00010 │ │ │ │ └── Nocycle_aDec_00010.java │ │ │ ├── RC0115-rc-function-RC_Dec-Nocycle_aDec_00020 │ │ │ │ └── Nocycle_aDec_00020.java │ │ │ ├── RC0116-rc-function-RC_Dec-Nocycle_aDec_00030 │ │ │ │ └── Nocycle_aDec_00030.java │ │ │ ├── RC0117-rc-function-RC_Dec-Nocycle_aDec_00040 │ │ │ │ └── Nocycle_aDec_00040.java │ │ │ ├── RC0118-rc-function-RC_Dec-Nocycle_aDec_00050 │ │ │ │ └── Nocycle_aDec_00050.java │ │ │ ├── RC0119-rc-function-RC_Dec-Nocycle_aDec_00060 │ │ │ │ └── Nocycle_aDec_00060.java │ │ │ ├── RC0120-rc-function-RC_Thread01-Cycle_am_00180 │ │ │ │ └── Cycle_am_00180.java │ │ │ ├── RC0121-rc-function-RC_Thread01-Cycle_am_00190 │ │ │ │ └── Cycle_am_00190.java │ │ │ ├── RC0122-rc-function-RC_Thread01-Cycle_am_00200 │ │ │ │ └── Cycle_am_00200.java │ │ │ ├── RC0123-rc-function-RC_Thread01-Cycle_am_00210 │ │ │ │ └── Cycle_am_00210.java │ │ │ ├── RC0124-rc-function-RC_Thread01-Cycle_am_00220 │ │ │ │ └── Cycle_am_00220.java │ │ │ ├── RC0125-rc-function-RC_Thread01-Cycle_am_00230 │ │ │ │ └── Cycle_am_00230.java │ │ │ ├── RC0126-rc-function-RC_Thread01-Cycle_am_00240 │ │ │ │ └── Cycle_am_00240.java │ │ │ ├── RC0127-rc-function-RC_Thread01-Cycle_am_00250 │ │ │ │ └── Cycle_am_00250.java │ │ │ ├── RC0128-rc-function-RC_Thread01-Cycle_am_00260 │ │ │ │ └── Cycle_am_00260.java │ │ │ ├── RC0129-rc-function-RC_Thread01-Cycle_am_00270 │ │ │ │ └── Cycle_am_00270.java │ │ │ ├── RC0130-rc-function-RC_Thread01-Cycle_am_00280 │ │ │ │ └── Cycle_am_00280.java │ │ │ ├── RC0131-rc-function-RC_Thread01-Cycle_am_00290 │ │ │ │ └── Cycle_am_00290.java │ │ │ ├── RC0132-rc-function-RC_Thread01-Cycle_am_00300 │ │ │ │ └── Cycle_am_00300.java │ │ │ ├── RC0133-rc-function-RC_Thread01-Cycle_am_00310 │ │ │ │ └── Cycle_am_00310.java │ │ │ ├── RC0134-rc-function-RC_Thread01-Cycle_am_00320 │ │ │ │ └── Cycle_am_00320.java │ │ │ ├── RC0135-rc-function-RC_Thread01-Cycle_am_00330 │ │ │ │ └── Cycle_am_00330.java │ │ │ ├── RC0136-rc-function-RC_Thread01-Cycle_am_00340 │ │ │ │ └── Cycle_am_00340.java │ │ │ ├── RC0137-rc-function-RC_Thread01-Cycle_am_00350 │ │ │ │ └── Cycle_am_00350.java │ │ │ ├── RC0138-rc-function-RC_Thread01-Cycle_am_00360 │ │ │ │ └── Cycle_am_00360.java │ │ │ ├── RC0139-rc-function-RC_Thread01-Cycle_am_00370 │ │ │ │ └── Cycle_am_00370.java │ │ │ ├── RC0140-rc-function-RC_Thread01-Cycle_am_00380 │ │ │ │ └── Cycle_am_00380.java │ │ │ ├── RC0141-rc-function-RC_Thread01-Cycle_am_00390 │ │ │ │ └── Cycle_am_00390.java │ │ │ ├── RC0142-rc-function-RC_Thread01-Cycle_am_00400 │ │ │ │ └── Cycle_am_00400.java │ │ │ ├── RC0143-rc-function-RC_Thread01-Cycle_am_00410 │ │ │ │ └── Cycle_am_00410.java │ │ │ ├── RC0144-rc-function-RC_Thread01-Cycle_am_00420 │ │ │ │ └── Cycle_am_00420.java │ │ │ ├── RC0145-rc-function-RC_Thread01-Cycle_am_00430 │ │ │ │ └── Cycle_am_00430.java │ │ │ ├── RC0146-rc-function-RC_Thread01-Cycle_am_00440 │ │ │ │ └── Cycle_am_00440.java │ │ │ ├── RC0147-rc-function-RC_Thread01-Cycle_am_00450 │ │ │ │ └── Cycle_am_00450.java │ │ │ ├── RC0148-rc-function-RC_Thread01-Cycle_am_00460 │ │ │ │ └── Cycle_am_00460.java │ │ │ ├── RC0149-rc-function-RC_Thread01-Cycle_am_00470 │ │ │ │ └── Cycle_am_00470.java │ │ │ ├── RC0150-rc-function-RC_Thread01-Cycle_am_00480 │ │ │ │ └── Cycle_am_00480.java │ │ │ ├── RC0151-rc-function-RC_Thread01-Cycle_am_00490 │ │ │ │ └── Cycle_am_00490.java │ │ │ ├── RC0152-rc-function-RC_Thread01-Cycle_am_00500 │ │ │ │ └── Cycle_am_00500.java │ │ │ ├── RC0153-rc-function-RC_Thread01-Cycle_am_00510 │ │ │ │ └── Cycle_am_00510.java │ │ │ ├── RC0154-rc-function-RC_Thread01-Cycle_am_10010 │ │ │ │ └── Cycle_am_10010.java │ │ │ ├── RC0155-rc-function-RC_Thread01-Cycle_am_10020 │ │ │ │ └── Cycle_am_10020.java │ │ │ ├── RC0156-rc-function-RC_Thread01-Cycle_am_10030 │ │ │ │ └── Cycle_am_10030.java │ │ │ ├── RC0157-rc-function-RC_Thread01-Cycle_Bm_1_00010 │ │ │ │ └── Cycle_Bm_1_00010.java │ │ │ ├── RC0158-rc-function-RC_Thread01-Cycle_Bm_1_00020 │ │ │ │ └── Cycle_Bm_1_00020.java │ │ │ ├── RC0159-rc-function-RC_Thread01-Cycle_Bm_1_00030 │ │ │ │ └── Cycle_Bm_1_00030.java │ │ │ ├── RC0160-rc-function-RC_Thread01-Cycle_Bm_1_00040 │ │ │ │ └── Cycle_Bm_1_00040.java │ │ │ ├── RC0161-rc-function-RC_Thread01-Cycle_Bm_1_00050 │ │ │ │ └── Cycle_Bm_1_00050.java │ │ │ ├── RC0162-rc-function-RC_Thread01-Cycle_Bm_1_00060 │ │ │ │ └── Cycle_Bm_1_00060.java │ │ │ ├── RC0163-rc-function-RC_Thread01-Cycle_Bm_1_00070 │ │ │ │ └── Cycle_Bm_1_00070.java │ │ │ ├── RC0164-rc-function-RC_Thread01-Cycle_Bm_1_00080 │ │ │ │ └── Cycle_Bm_1_00080.java │ │ │ ├── RC0165-rc-function-RC_Thread01-Cycle_Bm_1_00090 │ │ │ │ └── Cycle_Bm_1_00090.java │ │ │ ├── RC0166-rc-function-RC_Thread01-Cycle_Bm_1_00100 │ │ │ │ └── Cycle_Bm_1_00100.java │ │ │ ├── RC0167-rc-function-RC_Thread01-Cycle_Bm_1_00110 │ │ │ │ └── Cycle_Bm_1_00110.java │ │ │ ├── RC0168-rc-function-RC_Thread01-Cycle_Bm_1_00120 │ │ │ │ └── Cycle_Bm_1_00120.java │ │ │ ├── RC0169-rc-function-RC_Thread01-Cycle_Bm_1_00130 │ │ │ │ └── Cycle_Bm_1_00130.java │ │ │ ├── RC0170-rc-function-RC_Thread01-Cycle_Bm_1_00140 │ │ │ │ └── Cycle_Bm_1_00140.java │ │ │ ├── RC0171-rc-function-RC_Thread01-Cycle_Bm_1_00150 │ │ │ │ └── Cycle_Bm_1_00150.java │ │ │ ├── RC0172-rc-function-RC_Thread01-Cycle_Bm_1_00160 │ │ │ │ └── Cycle_Bm_1_00160.java │ │ │ ├── RC0173-rc-function-RC_Thread01-Cycle_Bm_1_00170 │ │ │ │ └── Cycle_Bm_1_00170.java │ │ │ ├── RC0174-rc-function-RC_Thread01-Cycle_Bm_1_00180 │ │ │ │ └── Cycle_Bm_1_00180.java │ │ │ ├── RC0175-rc-function-RC_Thread01-Cycle_Bm_1_00190 │ │ │ │ └── Cycle_Bm_1_00190.java │ │ │ ├── RC0176-rc-function-RC_Thread01-Cycle_Bm_1_00200 │ │ │ │ └── Cycle_Bm_1_00200.java │ │ │ ├── RC0177-rc-function-RC_Thread01-Cycle_Bm_1_00210 │ │ │ │ └── Cycle_Bm_1_00210.java │ │ │ ├── RC0178-rc-function-RC_Thread01-Cycle_Bm_1_10010 │ │ │ │ └── Cycle_Bm_1_10010.java │ │ │ ├── RC0179-rc-function-RC_Thread01-Cycle_Bm_1_10020 │ │ │ │ └── Cycle_Bm_1_10020.java │ │ │ ├── RC0180-rc-function-RC_Thread01-Cycle_Bm_1_10030 │ │ │ │ └── Cycle_Bm_1_10030.java │ │ │ ├── RC0181-rc-function-RC_Thread01-Cycle_Bm_2_00010 │ │ │ │ └── Cycle_Bm_2_00010.java │ │ │ ├── RC0182-rc-function-RC_Thread01-Cycle_Bm_2_00020 │ │ │ │ └── Cycle_Bm_2_00020.java │ │ │ ├── RC0183-rc-function-RC_Thread01-Cycle_Bm_2_00030 │ │ │ │ └── Cycle_Bm_2_00030.java │ │ │ ├── RC0184-rc-function-RC_Thread01-Cycle_Bm_2_00040 │ │ │ │ └── Cycle_Bm_2_00040.java │ │ │ ├── RC0185-rc-function-RC_Thread01-Cycle_Bm_2_00050 │ │ │ │ └── Cycle_Bm_2_00050.java │ │ │ ├── RC0186-rc-function-RC_Thread01-Cycle_Bm_2_00060 │ │ │ │ └── Cycle_Bm_2_00060.java │ │ │ ├── RC0187-rc-function-RC_Thread01-Cycle_Bm_2_00070 │ │ │ │ └── Cycle_Bm_2_00070.java │ │ │ ├── RC0188-rc-function-RC_Thread01-Cycle_Bm_2_00080 │ │ │ │ └── Cycle_Bm_2_00080.java │ │ │ ├── RC0189-rc-function-RC_Thread01-Cycle_Bm_2_00090 │ │ │ │ └── Cycle_Bm_2_00090.java │ │ │ ├── RC0190-rc-function-RC_Thread01-Cycle_Bm_2_00100 │ │ │ │ └── Cycle_Bm_2_00100.java │ │ │ ├── RC0191-rc-function-RC_Thread01-Cycle_Bm_2_00110 │ │ │ │ └── Cycle_Bm_2_00110.java │ │ │ ├── RC0192-rc-function-RC_Thread01-Cycle_Bm_2_00120 │ │ │ │ └── Cycle_Bm_2_00120.java │ │ │ ├── RC0193-rc-function-RC_Thread01-Cycle_Bm_2_00130 │ │ │ │ └── Cycle_Bm_2_00130.java │ │ │ ├── RC0194-rc-function-RC_Thread01-Cycle_Bm_2_00140 │ │ │ │ └── Cycle_Bm_2_00140.java │ │ │ ├── RC0195-rc-function-RC_Thread01-Cycle_Bm_2_00150 │ │ │ │ └── Cycle_Bm_2_00150.java │ │ │ ├── RC0196-rc-function-RC_Thread01-Cycle_Bm_2_00160 │ │ │ │ └── Cycle_Bm_2_00160.java │ │ │ ├── RC0197-rc-function-RC_Thread01-Cycle_Bm_2_00170 │ │ │ │ └── Cycle_Bm_2_00170.java │ │ │ ├── RC0198-rc-function-RC_Thread01-Cycle_Bm_2_00180 │ │ │ │ └── Cycle_Bm_2_00180.java │ │ │ ├── RC0199-rc-function-RC_Thread01-Cycle_Bm_2_00190 │ │ │ │ └── Cycle_Bm_2_00190.java │ │ │ ├── RC0200-rc-function-RC_Thread01-Cycle_Bm_2_00200 │ │ │ │ └── Cycle_Bm_2_00200.java │ │ │ ├── RC0201-rc-function-RC_Thread01-Cycle_Bm_2_00210 │ │ │ │ └── Cycle_Bm_2_00210.java │ │ │ ├── RC0202-rc-function-RC_Thread01-Cycle_Bm_2_00220 │ │ │ │ └── Cycle_Bm_2_00220.java │ │ │ ├── RC0203-rc-function-RC_Thread01-Cycle_Bm_2_00230 │ │ │ │ └── Cycle_Bm_2_00230.java │ │ │ ├── RC0204-rc-function-RC_Thread01-Cycle_Bm_2_00240 │ │ │ │ └── Cycle_Bm_2_00240.java │ │ │ ├── RC0205-rc-function-RC_Thread01-Cycle_Bm_2_10240 │ │ │ │ └── Cycle_Bm_2_10240.java │ │ │ ├── RC0207-rc-function-RC_Thread01-Nocycle_am_00020 │ │ │ │ └── Nocycle_am_00020.java │ │ │ ├── RC0208-rc-function-RC_Thread01-Nocycle_am_00030 │ │ │ │ └── Nocycle_am_00030.java │ │ │ ├── RC0209-rc-function-RC_Thread01-Nocycle_am_00040 │ │ │ │ └── Nocycle_am_00040.java │ │ │ ├── RC0210-rc-function-RC_Thread01-Nocycle_am_00050 │ │ │ │ └── Nocycle_am_00050.java │ │ │ ├── RC0211-rc-function-RC_Thread01-Nocycle_am_00060 │ │ │ │ └── Nocycle_am_00060.java │ │ │ ├── RC0212-rc-function-RC_Thread01-Nocycle_am_00070 │ │ │ │ └── Nocycle_am_00070.java │ │ │ ├── RC0213-rc-function-RC_Thread01-Nocycle_am_00080 │ │ │ │ └── Nocycle_am_00080.java │ │ │ ├── RC0214-rc-function-RC_Thread01-Nocycle_am_00090 │ │ │ │ └── Nocycle_am_00090.java │ │ │ ├── RC0215-rc-function-RC_Thread01-Nocycle_am_00100 │ │ │ │ └── Nocycle_am_00100.java │ │ │ ├── RC0216-rc-function-RC_Thread01-Nocycle_am_00110 │ │ │ │ └── Nocycle_am_00110.java │ │ │ ├── RC0217-rc-function-RC_Thread01-Nocycle_am_00120 │ │ │ │ └── Nocycle_am_00120.java │ │ │ ├── RC0218-rc-function-RC_Thread01-Nocycle_am_00130 │ │ │ │ └── Nocycle_am_00130.java │ │ │ ├── RC0219-rc-function-RC_Thread01-Nocycle_am_00140 │ │ │ │ └── Nocycle_am_00140.java │ │ │ ├── RC0220-rc-function-RC_Thread01-Nocycle_am_00150 │ │ │ │ └── Nocycle_am_00150.java │ │ │ ├── RC0221-rc-function-RC_Thread01-Nocycle_am_00160 │ │ │ │ └── Nocycle_am_00160.java │ │ │ ├── RC0222-rc-function-RC_Thread01-Nocycle_am_00170 │ │ │ │ └── Nocycle_am_00170.java │ │ │ ├── RC0223-rc-function-RC_Thread01-Nocycle_am_00180 │ │ │ │ └── Nocycle_am_00180.java │ │ │ ├── RC0224-rc-function-RC_Thread01-Nocycle_am_00190 │ │ │ │ └── Nocycle_am_00190.java │ │ │ ├── RC0225-rc-function-RC_Thread01-Nocycle_am_2_00010 │ │ │ │ └── Nocycle_am_2_00010.java │ │ │ ├── RC0226-rc-function-RC_Thread01-Nocycle_am_2_00020 │ │ │ │ └── Nocycle_am_2_00020.java │ │ │ ├── RC0227-rc-function-RC_Thread01-Nocycle_am_2_00030 │ │ │ │ └── Nocycle_am_2_00030.java │ │ │ ├── RC0228-rc-function-RC_Thread02-RC_Thread_01 │ │ │ │ └── RC_Thread_01.java │ │ │ ├── RC0229-rc-function-RC_Thread02-RC_Thread_02 │ │ │ │ └── RC_Thread_02.java │ │ │ ├── RC0230-rc-function-RC_Thread02-RC_Thread_03 │ │ │ │ └── RC_Thread_03.java │ │ │ ├── RC0231-rc-function-RC_Thread02-RC_Thread_04 │ │ │ │ └── RC_Thread_04.java │ │ │ ├── RC0232-rc-function-RC_Thread02-RC_Thread_05 │ │ │ │ └── RC_Thread_05.java │ │ │ ├── RC0233-rc-function-RC_Thread02-RC_Thread_06 │ │ │ │ └── RC_Thread_06.java │ │ │ ├── RC0234-rc-function-RC_Thread02-RC_Thread_07 │ │ │ │ └── RC_Thread_07.java │ │ │ ├── RC0235-rc-function-RC_Thread02-RC_Thread_08 │ │ │ │ └── RC_Thread_08.java │ │ │ ├── RC0236-rc-function-RC_Thread02-RC_Thread_09 │ │ │ │ └── RC_Thread_09.java │ │ │ ├── RC0237-rc-function-RC_Thread02-RC_Thread_10 │ │ │ │ └── RC_Thread_10.java │ │ │ ├── RC0238-rc-function-RC_Thread02-RC_Thread_11 │ │ │ │ └── RC_Thread_11.java │ │ │ ├── RC0239-rc-function-RC_Thread02-RC_Thread_12 │ │ │ │ └── RC_Thread_12.java │ │ │ ├── RC0240-rc-function-RC_Thread02-RC_Thread_13 │ │ │ │ └── RC_Thread_13.java │ │ │ ├── RC0241-rc-function-RC_Thread02-RC_Thread_14 │ │ │ │ └── RC_Thread_14.java │ │ │ ├── RC0242-rc-function-RC_Thread02-RC_Thread_15 │ │ │ │ └── RC_Thread_15.java │ │ │ ├── RC0243-rc-function-RC_Thread02-RC_Thread_16 │ │ │ │ └── RC_Thread_16.java │ │ │ ├── RC0244-rc-function-RC_Thread02-RC_Thread_17 │ │ │ │ └── RC_Thread_17.java │ │ │ ├── RC0245-rc-function-RC_Thread02-RC_Thread_18 │ │ │ │ └── RC_Thread_18.java │ │ │ ├── RC0246-rc-function-RC_Thread02-RC_Thread_19 │ │ │ │ └── RC_Thread_19.java │ │ │ ├── RC0247-rc-function-RC_Thread02-RC_Thread_20 │ │ │ │ └── RC_Thread_20.java │ │ │ ├── RC0248-rc-function-RC_Finalize_02 │ │ │ │ └── RC_Finalize_02.java │ │ │ ├── RC0250-rc-function-ROSAlloc-Alloc_11_15x8B │ │ │ │ └── Alloc_11_15x8B.java │ │ │ ├── RC0251-rc-function-ROSAlloc-Alloc_128x8B │ │ │ │ └── Alloc_128x8B.java │ │ │ ├── RC0252-rc-function-ROSAlloc-Alloc_16_20x8B │ │ │ │ └── Alloc_16_20x8B.java │ │ │ ├── RC0253-rc-function-ROSAlloc-Alloc_192x8B │ │ │ │ └── Alloc_192x8B.java │ │ │ ├── RC0254-rc-function-ROSAlloc-Alloc_21_25x8B │ │ │ │ └── Alloc_21_25x8B.java │ │ │ ├── RC0255-rc-function-ROSAlloc-Alloc_256x8B │ │ │ │ └── Alloc_256x8B.java │ │ │ ├── RC0256-rc-function-ROSAlloc-Alloc_26_30x8B │ │ │ │ └── Alloc_26_30x8B.java │ │ │ ├── RC0257-rc-function-ROSAlloc-Alloc_3_10x8B │ │ │ │ └── Alloc_3_10x8B.java │ │ │ ├── RC0258-rc-function-ROSAlloc-Alloc_31_35x8B │ │ │ │ └── Alloc_31_35x8B.java │ │ │ ├── RC0259-rc-function-ROSAlloc-Alloc_36_40x8B │ │ │ │ └── Alloc_36_40x8B.java │ │ │ ├── RC0260-rc-function-ROSAlloc-Alloc_41_45x8B │ │ │ │ └── Alloc_41_45x8B.java │ │ │ ├── RC0261-rc-function-ROSAlloc-Alloc_46_50x8B │ │ │ │ └── Alloc_46_50x8B.java │ │ │ ├── RC0262-rc-function-ROSAlloc-Alloc_51_55x8B │ │ │ │ └── Alloc_51_55x8B.java │ │ │ ├── RC0263-rc-function-ROSAlloc-Alloc_56_60x8B │ │ │ │ └── Alloc_56_60x8B.java │ │ │ ├── RC0264-rc-function-ROSAlloc-Alloc_61_64x8B │ │ │ │ └── Alloc_61_64x8B.java │ │ │ ├── RC0265-rc-function-ROSAlloc-Alloc_B256x8B │ │ │ │ └── Alloc_B256x8B.java │ │ │ ├── RC0281-rc-function-ROSAlloc-Alloc_Thread2_64x8B │ │ │ │ └── Alloc_Thread2_64x8B.java │ │ │ ├── RC0293-rc-function-ROSAlloc-Alloc_Threadm_192x8B │ │ │ │ └── Alloc_Threadm_192x8B.java │ │ │ ├── RC0294-rc-function-ROSAlloc-Alloc_Threadm_256x8B_2 │ │ │ │ └── Alloc_Threadm_256x8B_2.java │ │ │ ├── RC0295-rc-function-ROSAlloc-Alloc_Threadm_256x8B │ │ │ │ └── Alloc_Threadm_256x8B.java │ │ │ ├── RC0302-rc-function-Ref-PhantomRefTest │ │ │ │ └── PhantomRefTest.java │ │ │ ├── RC0303-rc-function-Ref-SoftRefTest │ │ │ │ └── SoftRefTest.java │ │ │ ├── RC0305-rc-function-SubsumeRC01 │ │ │ │ └── SubsumeRC01.java │ │ │ ├── RC0306-rc-function-SubsumeRC02 │ │ │ │ └── SubsumeRC02.java │ │ │ ├── RC0307-rc-function-SubsumeRC03 │ │ │ │ └── SubsumeRC03.java │ │ │ ├── RC0308-rc-function-CondBasedRC01 │ │ │ │ └── CondBasedRC01.java │ │ │ ├── RC0309-rc-function-Optimization-RC_newObjectIassign_01 │ │ │ │ └── RC_newObjectIassign_01.java │ │ │ ├── RC0310-rc-function-Optimization-RC_newObjectIassign_02 │ │ │ │ └── RC_newObjectIassign_02.java │ │ │ ├── RC0311-rc-function-Optimization-RC_newObjectToField │ │ │ │ └── RC_newObjectToField.java │ │ │ ├── RC0312-rc-function-Optimization-RC_newObjectToField_02 │ │ │ │ └── RC_newObjectToField_02.java │ │ │ ├── RC0313-rc-function-Optimization-RC_staticInput │ │ │ │ └── RC_staticInput.java │ │ │ └── RC0314-rc-function-Optimization-RC_staticInput_02 │ │ │ │ └── RC_staticInput_02.java │ │ ├── MemoryTest │ │ │ ├── RC0360-rc-Memory-leaktestsupplycase-01 │ │ │ │ └── BackupTracingAndRefPro.java │ │ │ ├── RC0364-rc-Memory-leaktestsupplycase-05 │ │ │ │ └── RaceInLoadAndWriteWeakRef.java │ │ │ ├── RC0365-rc-Memory-leaktestsupplycase-06 │ │ │ │ └── WeakAndCleanerRef.java │ │ │ └── RC0410-rc-Memory-stressTestCase29 │ │ │ │ └── Memory_stressTestCase29.java │ │ ├── RP │ │ │ ├── RC0348-rc-rp-simpleweakref_01 │ │ │ │ └── DeadReferenceTest.java │ │ │ ├── RC0349-rc-rp-simpleweakref_02 │ │ │ │ └── IsCleanerInDeadCycle.java │ │ │ ├── RC0351-rc-rp-simpleweakref_04 │ │ │ │ └── IsCleanerNotInDeadCycleFreeRef.java │ │ │ ├── RC0354-rc-rp-simpleweakref_07 │ │ │ │ └── IsCleanerNotInDeadCycleNotSetWCBFailAtomic.java │ │ │ ├── RC0355-rc-rp-simpleweakref_08 │ │ │ │ └── NotIsCleanerNotInDeadCycleNotSetWCBFailAtomic.java │ │ │ ├── RC0452-rc-RP-FinalizerReferenceTest04 │ │ │ │ └── FinalizerReferenceTest04.java │ │ │ └── RC0456-rc-RP-FinalizerReferenceTest08 │ │ │ │ └── FinalizerReferenceTest08.java │ │ ├── SoftRef │ │ │ ├── RC0431-rc-SoftRef-SoftRefTest │ │ │ │ └── SoftRefTest.java │ │ │ ├── RC0432-rc-SoftRef-SoftRefTest02 │ │ │ │ └── SoftRefTest02.java │ │ │ └── RC0435-rc-SoftRef-SoftRefTest05 │ │ │ │ └── SoftRefTest05.java │ │ └── StackScan │ │ │ ├── RC0477-rc-StackScan-CB_01 │ │ │ └── CB_01.java │ │ │ ├── RC0478-rc-StackScan-CB_02 │ │ │ └── CB_02.java │ │ │ ├── RC0479-rc-StackScan-CB_03 │ │ │ └── CB_03.java │ │ │ ├── RC0480-rc-StackScan-CB_04 │ │ │ └── CB_04.java │ │ │ ├── RC0481-rc-StackScan-CB_05 │ │ │ └── CB_05.java │ │ │ ├── RC0482-rc-StackScan-CB_06 │ │ │ └── CB_06.java │ │ │ ├── RC0483-rc-StackScan-CB_07 │ │ │ └── CB_07.java │ │ │ ├── RC0484-rc-StackScan-CB_08 │ │ │ └── CB_08.java │ │ │ ├── RC0485-rc-StackScan-CB_09 │ │ │ └── CB_09.java │ │ │ ├── RC0488-rc-StackScan-CP_Thread_03 │ │ │ └── CP_Thread_03.java │ │ │ ├── RC0489-rc-StackScan-CP_Thread_04 │ │ │ └── CP_Thread_04.java │ │ │ ├── RC0490-rc-StackScan-CP_Thread_05 │ │ │ └── CP_Thread_05.java │ │ │ ├── RC0491-rc-StackScan-CP_Thread_06 │ │ │ └── CP_Thread_06.java │ │ │ ├── RC0492-rc-StackScan-CP_Thread_07 │ │ │ └── CP_Thread_07.java │ │ │ ├── RC0493-rc-StackScan-CP_Thread_08 │ │ │ └── CP_Thread_08.java │ │ │ └── RC0494-rc-StackScan-CP_Thread_09 │ │ │ └── CP_Thread_09.java │ ├── other_test │ │ ├── RT0001-rt-other-CharacterNativeUncover │ │ │ └── CharacterNativeUncover.java │ │ ├── RT0002-rt-other-ClassNativeUncover │ │ │ └── ClassNativeUncover.java │ │ ├── RT0003-rt-other-ConstructorNativeUncover │ │ │ └── ConstructorNativeUncover.java │ │ ├── RT0005-rt-other-MethodNativeUncover │ │ │ └── MethodNativeUncover.java │ │ ├── RT0006-rt-other-ThreadNativeUncover │ │ │ └── ThreadNativeUncover.java │ │ ├── RT0007-rt-other-ThrowableNativeUncover │ │ │ └── ThrowableNativeUncover.java │ │ └── issue-RT0630-rt-other-ArrayNativeUncover │ │ │ └── ArrayNativeUncover.java │ ├── parent_test │ │ ├── RT0001-rt-parent-AccessibleObjectExObjectequals │ │ │ └── AccessibleObjectExObjectequals.java │ │ ├── RT0002-rt-parent-AccessibleObjectExObjecthashCode │ │ │ └── AccessibleObjectExObjecthashCode.java │ │ ├── RT0003-rt-parent-AccessibleObjectExObjectnotifyAllIllegalMonitorStateException │ │ │ └── AccessibleObjectExObjectnotifyAllIllegalMonitorStateException.java │ │ ├── RT0004-rt-parent-AccessibleObjectExObjectnotifyIllegalMonitorStateException │ │ │ └── AccessibleObjectExObjectnotifyIllegalMonitorStateException.java │ │ ├── RT0005-rt-parent-AccessibleObjectExObjecttoString │ │ │ └── AccessibleObjectExObjecttoString.java │ │ ├── RT0006-rt-parent-AccessibleObjectExObjectwaitIllegalMonitorStateException │ │ │ └── AccessibleObjectExObjectwaitIllegalMonitorStateException.java │ │ ├── RT0007-rt-parent-ArrayExObjecthashCode │ │ │ └── ArrayExObjecthashCode.java │ │ ├── RT0008-rt-parent-ArrayExObjectnotifyAllIllegalMonitorStateException │ │ │ └── ArrayExObjectnotifyAllIllegalMonitorStateException.java │ │ ├── RT0009-rt-parent-ArrayExObjectnotifyIllegalMonitorStateException │ │ │ └── ArrayExObjectnotifyIllegalMonitorStateException.java │ │ ├── RT0010-rt-parent-ArrayExObjectwaitIllegalMonitorStateException │ │ │ └── ArrayExObjectwaitIllegalMonitorStateException.java │ │ ├── RT0011-rt-parent-ArrayExObjectwaitInterruptedException │ │ │ └── ArrayExObjectwaitInterruptedException.java │ │ ├── RT0012-rt-parent-ArrayExObjectwait │ │ │ └── ArrayExObjectwait.java │ │ ├── RT0013-rt-parent-CharacterExObjectgetClass │ │ │ └── CharacterExObjectgetClass.java │ │ ├── RT0014-rt-parent-CharacterExObjectnotifyIllegalMonitorStateException │ │ │ └── CharacterExObjectnotifyIllegalMonitorStateException.java │ │ ├── RT0015-rt-parent-CharacterExObjectwaitIllegalMonitorStateException │ │ │ └── CharacterExObjectwaitIllegalMonitorStateException.java │ │ ├── RT0016-rt-parent-CharacterExObjectwaitInterruptedException │ │ │ └── CharacterExObjectwaitInterruptedException.java │ │ ├── RT0017-rt-parent-CharacterExObjectwait │ │ │ └── CharacterExObjectwait.java │ │ ├── RT0018-rt-parent-CharacterSubsetExObjectgetClass │ │ │ └── CharacterSubsetExObjectgetClass.java │ │ ├── RT0019-rt-parent-CharacterSubsetExObjectnotifyAllIllegalMonitorStateException │ │ │ └── CharacterSubsetExObjectnotifyAllIllegalMonitorStateException.java │ │ ├── RT0020-rt-parent-CharacterSubsetExObjectnotifyIllegalMonitorStateException │ │ │ └── CharacterSubsetExObjectnotifyIllegalMonitorStateException.java │ │ ├── RT0021-rt-parent-CharacterSubsetExObjectwaitIllegalArgumentException │ │ │ └── CharacterSubsetExObjectwaitIllegalArgumentException.java │ │ ├── RT0022-rt-parent-CharacterSubsetExObjectwaitIllegalMonitorStateException │ │ │ └── CharacterSubsetExObjectwaitIllegalMonitorStateException.java │ │ ├── RT0023-rt-parent-CharacterSubsetExObjectwaitInterruptedException │ │ │ └── CharacterSubsetExObjectwaitInterruptedException.java │ │ ├── RT0024-rt-parent-ClassExObjectHashcode │ │ │ └── ClassExObjectHashcode.java │ │ ├── RT0025-rt-parent-ClassExObjectnotifyAllIllegalMonitorStateException │ │ │ └── ClassExObjectnotifyAllIllegalMonitorStateException.java │ │ ├── RT0026-rt-parent-ClassExObjectnotifyIllegalMonitorStateException │ │ │ └── ClassExObjectnotifyIllegalMonitorStateException.java │ │ ├── RT0027-rt-parent-ClassExObjectwaitIllegalArgumentException │ │ │ └── ClassExObjectwaitIllegalArgumentException.java │ │ ├── RT0028-rt-parent-ClassExObjectwaitInterruptedException │ │ │ └── ClassExObjectwaitInterruptedException.java │ │ ├── RT0029-rt-parent-ClassExObjectwait │ │ │ └── ClassExObjectwait.java │ │ ├── RT0030-rt-parent-ClassLoaderExObjectnotifyAllIllegalMonitorStateException │ │ │ └── ClassLoaderExObjectnotifyAllIllegalMonitorStateException.java │ │ ├── RT0031-rt-parent-ClassLoaderExObjectnotifyIllegalMonitorStateException │ │ │ └── ClassLoaderExObjectnotifyIllegalMonitorStateException.java │ │ ├── RT0032-rt-parent-ClassLoaderExObjectwaitIllegalArgumentException │ │ │ └── ClassLoaderExObjectwaitIllegalArgumentException.java │ │ ├── RT0033-rt-parent-ClassLoaderExObjectwaitIllegalMonitorStateException │ │ │ └── ClassLoaderExObjectwaitIllegalMonitorStateException.java │ │ ├── RT0034-rt-parent-ClassLoaderExObjectwaitInterruptedException │ │ │ └── ClassLoaderExObjectwaitInterruptedException.java │ │ ├── RT0035-rt-parent-ClassLoaderExObjectwait │ │ │ └── ClassLoaderExObjectwait.java │ │ ├── RT0042-rt-parent-ConstructorExAccessibleObjectisAccessible │ │ │ └── ConstructorExAccessibleObjectisAccessible.java │ │ ├── RT0044-rt-parent-ConstructorExAccessibleObjectsetAccessibleSecurityException │ │ │ └── ConstructorExAccessibleObjectsetAccessibleSecurityException.java │ │ ├── RT0048-rt-parent-ConstructorExExecutablegetExceptionTypes │ │ │ └── ConstructorExExecutablegetExceptionTypes.java │ │ ├── RT0049-rt-parent-ConstructorExExecutablegetGenericParameterTypes │ │ │ └── ConstructorExExecutablegetGenericParameterTypes.java │ │ ├── RT0050-rt-parent-ConstructorExObjectnotifyAllIllegalMonitorStateException │ │ │ └── ConstructorExObjectnotifyAllIllegalMonitorStateException.java │ │ ├── RT0051-rt-parent-ConstructorExObjectnotifyIllegalMonitorStateException │ │ │ └── ConstructorExObjectnotifyIllegalMonitorStateException.java │ │ ├── RT0052-rt-parent-ConstructorExObjectwaitIllegalArgumentException │ │ │ └── ConstructorExObjectwaitIllegalArgumentException.java │ │ ├── RT0053-rt-parent-ConstructorExObjectwaitIllegalMonitorStateException │ │ │ └── ConstructorExObjectwaitIllegalMonitorStateException.java │ │ ├── RT0054-rt-parent-ConstructorExObjectwaitInterruptedException │ │ │ └── ConstructorExObjectwaitInterruptedException.java │ │ ├── RT0055-rt-parent-ConstructorExObjectwait │ │ │ └── ConstructorExObjectwait.java │ │ ├── RT0061-rt-parent-FieldExAccessibleObjectisAccessible │ │ │ └── FieldExAccessibleObjectisAccessible.java │ │ ├── RT0063-rt-parent-FieldExAccessibleObjectsetAccessibleSecurityException │ │ │ └── FieldExAccessibleObjectsetAccessibleSecurityException.java │ │ ├── RT0064-rt-parent-FieldExObjectgetClass │ │ │ └── FieldExObjectgetClass.java │ │ ├── RT0065-rt-parent-FieldExObjectnotifyAllIllegalMonitorStateException │ │ │ └── FieldExObjectnotifyAllIllegalMonitorStateException.java │ │ ├── RT0066-rt-parent-FieldExObjectnotifyIllegalMonitorStateException │ │ │ └── FieldExObjectnotifyIllegalMonitorStateException.java │ │ ├── RT0067-rt-parent-FieldExObjectwaitIllegalArgumentException │ │ │ └── FieldExObjectwaitIllegalArgumentException.java │ │ ├── RT0068-rt-parent-FieldExObjectwaitIllegalMonitorStateException │ │ │ └── FieldExObjectwaitIllegalMonitorStateException.java │ │ ├── RT0069-rt-parent-FieldExObjectwaitInterruptedException │ │ │ └── FieldExObjectwaitInterruptedException.java │ │ ├── RT0070-rt-parent-FieldExObjectwait │ │ │ └── FieldExObjectwait.java │ │ ├── RT0075-rt-parent-MethodExAccessibleObjectisAccessible │ │ │ └── MethodExAccessibleObjectisAccessible.java │ │ ├── RT0076-rt-parent-MethodExAccessibleObjectisAnnotationPresentNullPointerException │ │ │ └── MethodExAccessibleObjectisAnnotationPresentNullPointerException.java │ │ ├── RT0077-rt-parent-MethodExAccessibleObjectSetAccessible │ │ │ └── MethodExAccessibleObjectSetAccessible.java │ │ ├── RT0079-rt-parent-MethodExExecutablegetAnnotationsByTypeNullPointerException │ │ │ └── MethodExExecutablegetAnnotationsByTypeNullPointerException.java │ │ ├── RT0081-rt-parent-MethodExExecutablegetGenericParameterTypesExceptions │ │ │ └── MethodExExecutablegetGenericParameterTypesExceptions.java │ │ ├── RT0082-rt-parent-MethodExObjectnotifyAllIllegalMonitorStateException │ │ │ └── MethodExObjectnotifyAllIllegalMonitorStateException.java │ │ ├── RT0083-rt-parent-MethodExObjectnotifyIllegalMonitorStateException │ │ │ └── MethodExObjectnotifyIllegalMonitorStateException.java │ │ ├── RT0084-rt-parent-MethodExObjectwaitIllegalArgumentException │ │ │ └── MethodExObjectwaitIllegalArgumentException.java │ │ ├── RT0085-rt-parent-MethodExObjectwaitIllegalMonitorStateException │ │ │ └── MethodExObjectwaitIllegalMonitorStateException.java │ │ ├── RT0086-rt-parent-MethodExObjectwaitInterruptedException │ │ │ └── MethodExObjectwaitInterruptedException.java │ │ ├── RT0087-rt-parent-MethodExObjectwait │ │ │ └── MethodExObjectwait.java │ │ ├── RT0088-rt-parent-ModifierExObjectgetClass │ │ │ └── ModifierExObjectgetClass.java │ │ ├── RT0089-rt-parent-ModifierExObjecthashCode │ │ │ └── ModifierExObjecthashCode.java │ │ ├── RT0090-rt-parent-ModifierExObjectnotifyAllIllegalMonitorStateException │ │ │ └── ModifierExObjectnotifyAllIllegalMonitorStateException.java │ │ ├── RT0091-rt-parent-ModifierExObjectnotifyIllegalMonitorStateException │ │ │ └── ModifierExObjectnotifyIllegalMonitorStateException.java │ │ ├── RT0092-rt-parent-ModifierExObjectwaitInterruptedException │ │ │ └── ModifierExObjectwaitInterruptedException.java │ │ ├── RT0093-rt-parent-ModifierExObjectwait │ │ │ └── ModifierExObjectwait.java │ │ ├── RT0094-rt-parent-ParameterExObjectgetClass │ │ │ └── ParameterExObjectgetClass.java │ │ ├── RT0095-rt-parent-ParameterExObjectnotifyAllIllegalMonitorStateException │ │ │ └── ParameterExObjectnotifyAllIllegalMonitorStateException.java │ │ ├── RT0096-rt-parent-ParameterExObjectnotifyIllegalMonitorStateException │ │ │ └── ParameterExObjectnotifyIllegalMonitorStateException.java │ │ ├── RT0097-rt-parent-ParameterExObjectwait │ │ │ └── ParameterExObjectwait.java │ │ ├── RT0098-rt-parent-ProxyExObjecthashCode │ │ │ └── ProxyExObjecthashCode.java │ │ ├── RT0099-rt-parent-ProxyExObjectnotifyAllIllegalMonitorStateException │ │ │ └── ProxyExObjectnotifyAllIllegalMonitorStateException.java │ │ ├── RT0100-rt-parent-ProxyExObjectnotifyIllegalMonitorStateException │ │ │ └── ProxyExObjectnotifyIllegalMonitorStateException.java │ │ ├── RT0101-rt-parent-ProxyExObjectwaitIllegalArgumentException │ │ │ └── ProxyExObjectwaitIllegalArgumentException.java │ │ ├── RT0102-rt-parent-ProxyExObjectwaitIllegalMonitorStateException │ │ │ └── ProxyExObjectwaitIllegalMonitorStateException.java │ │ ├── RT0103-rt-parent-ProxyExObjectwaitInterruptedException │ │ │ └── ProxyExObjectwaitInterruptedException.java │ │ ├── RT0104-rt-parent-ProxyExObjectwait │ │ │ └── ProxyExObjectwait.java │ │ ├── RT0105-rt-parent-ReflectPermissionExBasicPermissionimplies │ │ │ └── ReflectPermissionExBasicPermissionimplies.java │ │ ├── RT0106-rt-parent-ReflectPermissionExObjectgetClass │ │ │ └── ReflectPermissionExObjectgetClass.java │ │ ├── RT0107-rt-parent-ReflectPermissionExObjectnotifyAllIllegalMonitorStateException │ │ │ └── ReflectPermissionExObjectnotifyAllIllegalMonitorStateException.java │ │ ├── RT0108-rt-parent-ReflectPermissionExObjectnotifyIllegalMonitorStateException │ │ │ └── ReflectPermissionExObjectnotifyIllegalMonitorStateException.java │ │ ├── RT0109-rt-parent-ReflectPermissionExObjecttoString │ │ │ └── ReflectPermissionExObjecttoString.java │ │ ├── RT0110-rt-parent-ReflectPermissionExObjectwaitIllegalMonitorStateException │ │ │ └── ReflectPermissionExObjectwaitIllegalMonitorStateException.java │ │ ├── RT0111-rt-parent-ReflectPermissionExObjectwaitInterruptedException │ │ │ └── ReflectPermissionExObjectwaitInterruptedException.java │ │ ├── RT0112-rt-parent-ReflectPermissionExObjectwait │ │ │ └── ReflectPermissionExObjectwait.java │ │ ├── RT0113-rt-parent-ReflectPermissionExPermissioncheckGuard │ │ │ └── ReflectPermissionExPermissioncheckGuard.java │ │ ├── RT0114-rt-parent-StringBufferExObjectgetClass │ │ │ └── StringBufferExObjectgetClass.java │ │ ├── RT0115-rt-parent-StringBufferExObjecthashCode │ │ │ └── StringBufferExObjecthashCode.java │ │ ├── RT0116-rt-parent-StringBufferExObjectnotifyAllIllegalMonitorStateException │ │ │ └── StringBufferExObjectnotifyAllIllegalMonitorStateException.java │ │ ├── RT0117-rt-parent-StringBufferExObjectnotifyIllegalMonitorStateException │ │ │ └── StringBufferExObjectnotifyIllegalMonitorStateException.java │ │ ├── RT0118-rt-parent-StringBufferExObjectwaitIllegalArgumentException │ │ │ └── StringBufferExObjectwaitIllegalArgumentException.java │ │ ├── RT0119-rt-parent-StringBufferExObjectwaitIllegalMonitorStateException │ │ │ └── StringBufferExObjectwaitIllegalMonitorStateException.java │ │ ├── RT0120-rt-parent-StringBufferExObjectwait │ │ │ └── StringBufferExObjectwait.java │ │ ├── RT0121-rt-parent-StringBuilderExObjectgetClass │ │ │ └── StringBuilderExObjectgetClass.java │ │ ├── RT0122-rt-parent-StringBuilderExObjecthashCode │ │ │ └── StringBuilderExObjecthashCode.java │ │ ├── RT0123-rt-parent-StringBuilderExObjectnotifyAllIllegalMonitorStateException │ │ │ └── StringBuilderExObjectnotifyAllIllegalMonitorStateException.java │ │ ├── RT0124-rt-parent-StringBuilderExObjectnotifyIllegalMonitorStateException │ │ │ └── StringBuilderExObjectnotifyIllegalMonitorStateException.java │ │ ├── RT0125-rt-parent-StringBuilderExObjectwaitIllegalArgumentException │ │ │ └── StringBuilderExObjectwaitIllegalArgumentException.java │ │ ├── RT0126-rt-parent-StringBuilderExObjectwaitIllegalMonitorStateException │ │ │ └── StringBuilderExObjectwaitIllegalMonitorStateException.java │ │ ├── RT0127-rt-parent-StringBuilderExObjectwait │ │ │ └── StringBuilderExObjectwait.java │ │ ├── RT0128-rt-parent-StringExObjectgetClass │ │ │ └── StringExObjectgetClass.java │ │ ├── RT0129-rt-parent-StringExObjectnotifyAllIllegalMonitorStateException │ │ │ └── StringExObjectnotifyAllIllegalMonitorStateException.java │ │ ├── RT0130-rt-parent-StringExObjectnotifyIllegalMonitorStateException │ │ │ └── StringExObjectnotifyIllegalMonitorStateException.java │ │ ├── RT0131-rt-parent-StringExObjectwaitIllegalArgumentException │ │ │ └── StringExObjectwaitIllegalArgumentException.java │ │ ├── RT0132-rt-parent-StringExObjectwaitIllegalMonitorStateException │ │ │ └── StringExObjectwaitIllegalMonitorStateException.java │ │ ├── RT0133-rt-parent-StringExObjectwait │ │ │ └── StringExObjectwait.java │ │ ├── RT0134-rt-parent-ThreadExObjecthashCode │ │ │ └── ThreadExObjecthashCode.java │ │ ├── RT0135-rt-parent-ThreadExObjectnotifyAllIllegalMonitorStateException │ │ │ └── ThreadExObjectnotifyAllIllegalMonitorStateException.java │ │ ├── RT0136-rt-parent-ThreadExObjectnotifyIllegalMonitorStateException │ │ │ └── ThreadExObjectnotifyIllegalMonitorStateException.java │ │ ├── RT0137-rt-parent-ThreadExObjectwaitIllegalArgumentException │ │ │ └── ThreadExObjectwaitIllegalArgumentException.java │ │ ├── RT0138-rt-parent-ThreadExObjectwaitIllegalMonitorStateException │ │ │ └── ThreadExObjectwaitIllegalMonitorStateException.java │ │ ├── RT0139-rt-parent-ThreadExObjectwait │ │ │ └── ThreadExObjectwait.java │ │ ├── RT0140-rt-parent-ThreadGroupExObjectequals │ │ │ └── ThreadGroupExObjectequals.java │ │ ├── RT0141-rt-parent-ThreadGroupExObjectgetClass │ │ │ └── ThreadGroupExObjectgetClass.java │ │ ├── RT0142-rt-parent-ThreadGroupExObjecthashCode │ │ │ └── ThreadGroupExObjecthashCode.java │ │ ├── RT0143-rt-parent-ThreadGroupExObjectnotifyAllIllegalMonitorStateException │ │ │ └── ThreadGroupExObjectnotifyAllIllegalMonitorStateException.java │ │ ├── RT0144-rt-parent-ThreadGroupExObjectnotifyIllegalMonitorStateException │ │ │ └── ThreadGroupExObjectnotifyIllegalMonitorStateException.java │ │ ├── RT0145-rt-parent-ThreadGroupExObjecttoString │ │ │ └── ThreadGroupExObjecttoString.java │ │ ├── RT0146-rt-parent-ThreadGroupExObjectwaitIllegalArgumentException │ │ │ └── ThreadGroupExObjectwaitIllegalArgumentException.java │ │ ├── RT0147-rt-parent-ThreadGroupExObjectwaitIllegalMonitorStateException │ │ │ └── ThreadGroupExObjectwaitIllegalMonitorStateException.java │ │ ├── RT0148-rt-parent-ThreadGroupExObjectwaitInterruptedException │ │ │ └── ThreadGroupExObjectwaitInterruptedException.java │ │ ├── RT0149-rt-parent-ThreadLocalExObjectgetClass │ │ │ └── ThreadLocalExObjectgetClass.java │ │ ├── RT0150-rt-parent-ThreadLocalExObjecthashCode │ │ │ └── ThreadLocalExObjecthashCode.java │ │ ├── RT0151-rt-parent-ThreadLocalExObjectnotifyAllIllegalMonitorStateException │ │ │ └── ThreadLocalExObjectnotifyAllIllegalMonitorStateException.java │ │ ├── RT0152-rt-parent-ThreadLocalExObjectnotifyIllegalMonitorStateException │ │ │ └── ThreadLocalExObjectnotifyIllegalMonitorStateException.java │ │ ├── RT0153-rt-parent-ThreadLocalExObjecttoString │ │ │ └── ThreadLocalExObjecttoString.java │ │ ├── RT0154-rt-parent-ThreadLocalExObjectwaitIllegalArgumentException │ │ │ └── ThreadLocalExObjectwaitIllegalArgumentException.java │ │ ├── RT0155-rt-parent-ThreadLocalExObjectwaitIllegalMonitorStateException │ │ │ └── ThreadLocalExObjectwaitIllegalMonitorStateException.java │ │ ├── RT0156-rt-parent-ThreadLocalExObjectwaitInterruptedException │ │ │ └── ThreadLocalExObjectwaitInterruptedException.java │ │ ├── RT0157-rt-parent-ThrowableExObjecthashCode │ │ │ └── ThrowableExObjecthashCode.java │ │ ├── RT0158-rt-parent-ThrowableExObjectnotifyAllIllegalMonitorStateException │ │ │ └── ThrowableExObjectnotifyAllIllegalMonitorStateException.java │ │ ├── RT0159-rt-parent-ThrowableExObjectnotifyIllegalMonitorStateException │ │ │ └── ThrowableExObjectnotifyIllegalMonitorStateException.java │ │ ├── RT0160-rt-parent-ThrowableExObjectwaitIllegalArgumentException │ │ │ └── ThrowableExObjectwaitIllegalArgumentException.java │ │ ├── RT0161-rt-parent-ThrowableExObjectwaitIllegalMonitorStateException │ │ │ └── ThrowableExObjectwaitIllegalMonitorStateException.java │ │ ├── RT0162-rt-parent-ThrowableExObjectwaitInterruptedException │ │ │ └── ThrowableExObjectwaitInterruptedException.java │ │ ├── RT0163-rt-parent-ThrowableExObjectwait │ │ │ └── ThrowableExObjectwait.java │ │ ├── RT0164-rt-parent-UnicodeBlockExObjectgetClass │ │ │ └── UnicodeBlockExObjectgetClass.java │ │ ├── RT0165-rt-parent-UnicodeBlockExObjecthashCode │ │ │ └── UnicodeBlockExObjecthashCode.java │ │ ├── RT0166-rt-parent-UnicodeBlockExObjectnotifyAllIllegalMonitorStateException │ │ │ └── UnicodeBlockExObjectnotifyAllIllegalMonitorStateException.java │ │ ├── RT0167-rt-parent-UnicodeBlockExObjectnotifyIllegalMonitorStateException │ │ │ └── UnicodeBlockExObjectnotifyIllegalMonitorStateException.java │ │ ├── RT0168-rt-parent-UnicodeBlockExObjecttoString │ │ │ └── UnicodeBlockExObjecttoString.java │ │ ├── RT0169-rt-parent-UnicodeBlockExObjectwaitIllegalMonitorStateException │ │ │ └── UnicodeBlockExObjectwaitIllegalMonitorStateException.java │ │ ├── RT0170-rt-parent-UnicodeBlockExObjectwaitInterruptedException │ │ │ └── UnicodeBlockExObjectwaitInterruptedException.java │ │ ├── RT0171-rt-parent-UnicodeBlockExObjectwait │ │ │ └── UnicodeBlockExObjectwait.java │ │ ├── issue-RT0646-rt-parent-AccessibleObjectExObjectwaitInterruptedException │ │ │ └── AccessibleObjectExObjectwaitInterruptedException.java │ │ ├── issue-RT0654-rt-parent-CharacterExObjectnotifyAllIllegalMonitorStateException │ │ │ └── CharacterExObjectnotifyAllIllegalMonitorStateException.java │ │ ├── issue-RT0733-rt-parent-ModifierExObjectwaitIllegalArgumentException │ │ │ └── ModifierExObjectwaitIllegalArgumentException.java │ │ └── issue-RT0734-rt-parent-ModifierExObjectwaitIllegalMonitorStateException │ │ │ └── ModifierExObjectwaitIllegalMonitorStateException.java │ ├── reflection_test │ │ ├── RT0001-rt-reflection-ReflectingetConstructor1 │ │ │ └── ReflectingGetConstructor1.java │ │ ├── RT0002-rt-reflection-ReflectingetConstructor2 │ │ │ └── ReflectingGetConstructor2.java │ │ ├── RT0003-rt-reflection-ReflectingetConstructors │ │ │ └── ReflectingGetConstructors.java │ │ ├── RT0004-rt-reflection-ReflectingetDeclaredConstructor1 │ │ │ └── ReflectingGetDeclaredConstructor1.java │ │ ├── RT0005-rt-reflection-ReflectingetDeclaredConstructor2 │ │ │ └── ReflectingGetDeclaredConstructor2.java │ │ ├── RT0006-rt-reflection-ReflectingetDeclaredConstructors │ │ │ └── ReflectingGetDeclaredConstructors.java │ │ ├── RT0007-rt-reflection-ReflectionasSubclass1 │ │ │ └── ReflectionAsSubclass1.java │ │ ├── RT0008-rt-reflection-ReflectionasSubclass2 │ │ │ └── ReflectionAsSubclass2.java │ │ ├── RT0009-rt-reflection-ReflectionasSubclass3 │ │ │ └── ReflectionAsSubclass3.java │ │ ├── RT0010-rt-reflection-Reflectioncast1 │ │ │ └── ReflectionCast1.java │ │ ├── RT0011-rt-reflection-Reflectioncast2 │ │ │ └── ReflectionCast2.java │ │ ├── RT0012-rt-reflection-Reflectioncast3 │ │ │ └── ReflectionCast3.java │ │ ├── RT0013-rt-reflection-Reflectioncast4 │ │ │ └── ReflectionCast4.java │ │ ├── RT0014-rt-reflection-ReflectiondesiredAssertionStatus │ │ │ └── ReflectionDesiredAssertionStatus.java │ │ ├── RT0015-rt-reflection-ReflectionforName1 │ │ │ └── ReflectionForName1.java │ │ ├── RT0016-rt-reflection-ReflectionforName4 │ │ │ └── ReflectionForName4.java │ │ ├── RT0017-rt-reflection-ReflectionforName5 │ │ │ └── ReflectionForName5.java │ │ ├── RT0020-rt-reflection-ReflectiongetAnnotation3 │ │ │ └── ReflectionGetAnnotation3.java │ │ ├── RT0021-rt-reflection-ReflectiongetAnnotation4 │ │ │ └── ReflectionGetAnnotation4.java │ │ ├── RT0026-rt-reflection-ReflectiongetAnnotationsByType2 │ │ │ └── ReflectionGetAnnotationsByType2.java │ │ ├── RT0028-rt-reflection-ReflectiongetCanonicalName │ │ │ └── ReflectionGetCanonicalName.java │ │ ├── RT0029-rt-reflection-ReflectiongetComponentType │ │ │ └── ReflectionGetComponentType.java │ │ ├── RT0030-rt-reflection-ReflectiongetDeclaredAnnotations1 │ │ │ └── ReflectionGetDeclaredAnnotations1.java │ │ ├── RT0031-rt-reflection-ReflectiongetDeclaredAnnotations2 │ │ │ └── ReflectionGetDeclaredAnnotations2.java │ │ ├── RT0033-rt-reflection-ReflectionGetDeclaredAnnotationsByTypeNullPointerException │ │ │ └── ReflectionGetDeclaredAnnotationsByTypeNullPointerException.java │ │ ├── RT0034-rt-reflection-ReflectiongetDeclaredClasses │ │ │ └── ReflectionGetDeclaredClasses.java │ │ ├── RT0035-rt-reflection-ReflectiongetDeclaredField1 │ │ │ └── ReflectionGetDeclaredField1.java │ │ ├── RT0036-rt-reflection-ReflectionGetDeclaredFieldNullPointerException │ │ │ └── ReflectionGetDeclaredFieldNullPointerException.java │ │ ├── RT0037-rt-reflection-ReflectiongetDeclaredFields1 │ │ │ └── ReflectionGetDeclaredFields1.java │ │ ├── RT0038-rt-reflection-ReflectiongetDeclaredFields2 │ │ │ └── ReflectionGetDeclaredFields.java │ │ ├── RT0039-rt-reflection-ReflectiongetDeclaredMethod1 │ │ │ └── ReflectionGetDeclaredMethod1.java │ │ ├── RT0040-rt-reflection-ReflectiongetDeclaredMethod2 │ │ │ └── ReflectionGetDeclaredMethod2.java │ │ ├── RT0041-rt-reflection-ReflectiongetDeclaredMethod3 │ │ │ └── ReflectionGetDeclaredMethod3.java │ │ ├── RT0042-rt-reflection-ReflectiongetDeclaredMethods1 │ │ │ └── ReflectionGetDeclaredMethods1.java │ │ ├── RT0043-rt-reflection-ReflectiongetDeclaredMethods2 │ │ │ └── ReflectionGetDeclaredMethods2.java │ │ ├── RT0044-rt-reflection-ReflectiongetDeclaringClass │ │ │ └── ReflectionGetDeclaringClass.java │ │ ├── RT0047-rt-reflection-ReflectiongetEnumConstants │ │ │ └── ReflectionGetEnumConstants.java │ │ ├── RT0048-rt-reflection-ReflectiongetField1 │ │ │ └── ReflectionGetField1.java │ │ ├── RT0049-rt-reflection-ReflectiongetField2 │ │ │ └── ReflectionGetField2.java │ │ ├── RT0050-rt-reflection-ReflectiongetFields │ │ │ └── ReflectionGetFields.java │ │ ├── RT0051-rt-reflection-ReflectiongetMethod1 │ │ │ └── ReflectionGetMethod1.java │ │ ├── RT0052-rt-reflection-ReflectiongetMethod2 │ │ │ └── ReflectionGetMethod2.java │ │ ├── RT0053-rt-reflection-ReflectiongetSigners │ │ │ └── ReflectionGetSigners.java │ │ ├── RT0054-rt-reflection-ReflectiongetSimpleName │ │ │ └── ReflectionGetSimpleName.java │ │ ├── RT0056-rt-reflection-ReflectionisArray │ │ │ └── ReflectionIsArray.java │ │ ├── RT0057-rt-reflection-ReflectionisAssignableFrom1 │ │ │ └── ReflectionIsAssignableFrom1.java │ │ ├── RT0058-rt-reflection-ReflectionisAssignableFrom2 │ │ │ └── ReflectionIsAssignableFromNullPointerException.java │ │ ├── RT0059-rt-reflection-ReflectionisLocalClass │ │ │ └── ReflectionIsLocalClass.java │ │ ├── RT0060-rt-reflection-ReflectionisMemberClass │ │ │ └── ReflectionIsMemberClass.java │ │ ├── RT0061-rt-reflection-ReflectionisPrimitive │ │ │ └── ReflectionIsPrimitive.java │ │ ├── RT0062-rt-reflection-ReflectionisSynthetic │ │ │ └── ReflectionIsSynthetic.java │ │ ├── RT0063-rt-reflection-ReflectionnewInstance1 │ │ │ └── ReflectionNewInstance1.java │ │ ├── RT0064-rt-reflection-ReflectionnewInstance2 │ │ │ └── ReflectionNewInstanceInstantiationExceptionIllegalAccessException.java │ │ ├── RT0065-rt-reflection-ReflectiontoGenericString │ │ │ └── ReflectionToGenericString.java │ │ ├── RT0066-rt-reflection-ReflectiontoString │ │ │ └── ReflectionToString.java │ │ ├── RT0068-rt-reflection-RTConstructorgetAnnotation2 │ │ │ └── RTConstructorGetAnnotation2.java │ │ ├── RT0070-rt-reflection-RTConstructorgetDeclaredAnnotations2 │ │ │ └── RTConstructorGetDeclaredAnnotations2.java │ │ ├── RT0074-rt-reflection-RTFieldget1 │ │ │ └── RTFieldGet1.java │ │ ├── RT0075-rt-reflection-RTFieldget2 │ │ │ └── RTFieldGet2.java │ │ ├── RT0076-rt-reflection-RTFieldget3 │ │ │ └── RTFieldGet3.java │ │ ├── RT0077-rt-reflection-RTFieldgetAnnotation │ │ │ └── RTFieldGetAnnotation1.java │ │ ├── RT0079-rt-reflection-RTFieldgetDeclaredAnnotations2 │ │ │ └── RTFieldGetDeclaredAnnotations2.java │ │ ├── RT0080-rt-reflection-RTFieldgetDeclaringClass │ │ │ └── RTFieldGetDeclaringClass.java │ │ ├── RT0081-rt-reflection-RTFieldgetModifiers │ │ │ └── RTFieldGetModifiers.java │ │ ├── RT0082-rt-reflection-RTFieldgetName │ │ │ └── RTFieldGetName.java │ │ ├── RT0083-rt-reflection-RTFieldgetType │ │ │ └── RTFieldGetType.java │ │ ├── RT0084-rt-reflection-RTFieldset1 │ │ │ └── RTFieldSet1.java │ │ ├── RT0085-rt-reflection-RTFieldset2 │ │ │ └── RTFieldSet2.java │ │ ├── RT0086-rt-reflection-RTFieldset3 │ │ │ └── RTFieldSet3.java │ │ ├── RT0087-rt-reflection-RTFieldset4 │ │ │ └── RTFieldSet4.java │ │ ├── RT0089-rt-reflection-RTFieldtoString │ │ │ └── RTFieldToString.java │ │ ├── RT0091-rt-reflection-RTMethodgetAnnotation2 │ │ │ └── RTMethodGetAnnotation2.java │ │ ├── RT0093-rt-reflection-RTMethodgetDeclaredAnnotations2 │ │ │ └── RTMethodGetDeclaredAnnotations2.java │ │ ├── RT0095-rt-reflection-RTMethodgetParameterCount │ │ │ └── RTMethodGetParameterCount.java │ │ ├── RT0097-rt-reflection-RTMethonisDefault │ │ │ └── RTMethodIsDefault.java │ │ ├── RT0099-rt-reflection-RTModifierparameterModifiers │ │ │ └── RTModifierParameterModifiers.java │ │ ├── RT0101-rt-reflection-RTParametergetAnnotation2 │ │ │ └── RTParameterGetAnnotation2.java │ │ ├── RT0104-rt-reflection-RTParametergetAnnotationsByType2 │ │ │ └── RTParameterGetAnnotationsByType2.java │ │ ├── RT0107-rt-reflection-RTParametergetDeclaredAnnotations2 │ │ │ └── RTParameterGetDeclaredAnnotations2.java │ │ ├── RT0109-rt-reflection-RTProxygetProxyClass1 │ │ │ └── RTProxyGetProxyClass1.java │ │ ├── RT0110-rt-reflection-ClassgetDeclaredAnnotationNPE │ │ │ └── ClassGetDeclaredAnnotationNPE.java │ │ ├── RT0111-rt-reflection-reflectClasssetisAssignableFrom │ │ │ └── ClassIsAssignableFromNPE.java │ │ ├── RT0112-rt-reflection-ClassGetAnnotationsByType │ │ │ └── ClassGetAnnotationsByType.java │ │ ├── RT0115-rt-reflection-ClassGetEnumConstants │ │ │ └── ClassGetEnumConstants.java │ │ ├── RT0117-rt-reflection-ClassGetTypeParameters │ │ │ └── ClassGetTypeParameters.java │ │ ├── RT0118-rt-reflection-ClassToGenericString │ │ │ └── ClassToGenericString.java │ │ ├── RT0121-rt-reflection-ConstructorGetExceptionTypes │ │ │ └── ConstructorGetExceptionTypes.java │ │ ├── RT0122-rt-reflection-ConstructorGetTypeParameters │ │ │ └── ConstructorGetTypeParameters.java │ │ ├── RT0123-rt-reflection-ConstructorToGenericString │ │ │ └── ConstructorToGenericString.java │ │ ├── RT0128-rt-reflection-FieldToGenericString │ │ │ └── FieldToGenericString.java │ │ ├── RT0131-rt-reflection-MethodgetDefaultValue │ │ │ └── MethodGetDefaultValue.java │ │ ├── RT0132-rt-reflection-MethodGetParameterCount │ │ │ └── MethodGetParameterCount.java │ │ ├── RT0133-rt-reflection-MethodGetTypeParameters │ │ │ └── MethodGetTypeParameters.java │ │ ├── RT0134-rt-reflection-MethodIsDefault │ │ │ └── MethodIsDefault.java │ │ ├── RT0135-rt-reflection-MethodToGenericString │ │ │ └── MethodToGenericString.java │ │ ├── RT0142-rt-reflection-ReflectionAnnotationGetClass │ │ │ └── ReflectionAnnotationGetClass.java │ │ ├── RT0143-rt-reflection-ClinitClassNewInstance │ │ │ └── ClassInitClassNewInstance.java │ │ ├── RT0144-rt-reflection-ClinitConstructorNewInstance │ │ │ └── ClassInitConstructorNewInstance.java │ │ ├── RT0145-rt-reflection-ClinitFieldGetBooleanStatic │ │ │ └── ClassInitFieldGetBooleanStatic.java │ │ ├── RT0146-rt-reflection-ClinitFieldGetByteStatic │ │ │ └── ClassInitFieldGetByteStatic.java │ │ ├── RT0147-rt-reflection-ClinitFieldGetCharStatic │ │ │ └── ClassInitFieldGetCharStatic.java │ │ ├── RT0148-rt-reflection-ClinitFieldGetDoubleStatic │ │ │ └── ClassInitFieldGetDoubleStatic.java │ │ ├── RT0149-rt-reflection-ClinitFieldGetFloatStatic │ │ │ └── ClassInitFieldGetFloatStatic.java │ │ ├── RT0150-rt-reflection-ClinitFieldGetIntStatic │ │ │ └── ClassInitFieldGetIntStatic.java │ │ ├── RT0151-rt-reflection-ClinitFieldGetLongStatic │ │ │ └── ClassInitFieldGetLongStatic.java │ │ ├── RT0152-rt-reflection-ClinitFieldGetShortStatic │ │ │ └── ClassInitFieldGetShortStatic.java │ │ ├── RT0153-rt-reflection-ClinitFieldGetStatic │ │ │ └── ClassInitFieldGetStatic.java │ │ ├── RT0154-rt-reflection-ClinitFieldOtherMethod │ │ │ └── ClassInitFieldOtherMethod.java │ │ ├── RT0155-rt-reflection-ClinitFieldSetBooleanStatic │ │ │ └── ClassInitFieldSetBooleanStatic.java │ │ ├── RT0156-rt-reflection-ClinitFieldSetByteStatic │ │ │ └── ClassInitFieldSetByteStatic.java │ │ ├── RT0157-rt-reflection-ClinitFieldSetCharStatic │ │ │ └── ClassInitFieldSetCharStatic.java │ │ ├── RT0158-rt-reflection-ClinitFieldSetDoubleStatic │ │ │ └── ClassInitFieldSetDoubleStatic.java │ │ ├── RT0159-rt-reflection-ClinitFieldSetFloatStatic │ │ │ └── ClassInitFieldSetFloatStatic.java │ │ ├── RT0160-rt-reflection-ClinitFieldSetIntStatic │ │ │ └── ClassInitFieldSetIntStatic.java │ │ ├── RT0161-rt-reflection-ClinitFieldSetLongStatic │ │ │ └── ClassInitFieldSetLongStatic.java │ │ ├── RT0162-rt-reflection-ClinitFieldSetShortStatic │ │ │ └── ClassInitFieldSetShortStatic.java │ │ ├── RT0163-rt-reflection-ClinitFieldSetStatic │ │ │ └── ClassInitFieldSetStatic.java │ │ ├── RT0164-rt-reflection-ClinitMethodInvokeStatic │ │ │ └── ClassInitMethodInvokeStatic.java │ │ ├── RT0165-rt-reflection-ClinitFieldGetBooleanInterface │ │ │ └── ClassInitFieldGetBooleanInterface.java │ │ ├── RT0166-rt-reflection-ClinitFieldGetByteInterface │ │ │ └── ClassInitFieldGetByteInterface.java │ │ ├── RT0167-rt-reflection-ClinitFieldGetCharInterface │ │ │ └── ClassInitFieldGetCharInterface.java │ │ ├── RT0168-rt-reflection-ClinitFieldGetDoubleInterface │ │ │ └── ClassInitFieldGetDoubleInterface.java │ │ ├── RT0169-rt-reflection-ClinitFieldGetFloatInterface │ │ │ └── ClassInitFieldGetFloatInterface.java │ │ ├── RT0170-rt-reflection-ClinitFieldGetInterface │ │ │ └── ClassInitFieldGetInterface.java │ │ ├── RT0171-rt-reflection-ClinitFieldGetIntInterface │ │ │ └── ClassInitFieldGetIntInterface.java │ │ ├── RT0172-rt-reflection-ClinitFieldGetLongInterface │ │ │ └── ClassInitFieldGetLongInterface.java │ │ ├── RT0173-rt-reflection-ClinitFieldGetShortInterface │ │ │ └── ClassInitFieldGetShortInterface.java │ │ ├── RT0174-rt-reflection-ClinitFieldOtherMethodInterface │ │ │ └── ClassInitFieldOtherMethodInterface.java │ │ ├── RT0175-rt-reflection-ClinitFieldSetBooleanInterface │ │ │ └── ClassInitFieldSetBooleanInterface.java │ │ ├── RT0176-rt-reflection-ClinitFieldSetByteInterface │ │ │ └── ClassInitFieldSetByteInterface.java │ │ ├── RT0177-rt-reflection-ClinitFieldSetFloatInterface │ │ │ └── ClassInitFieldSetFloatInterface.java │ │ ├── RT0178-rt-reflection-ClinitFieldSetInterface │ │ │ └── ClassInitFieldSetInterface.java │ │ ├── RT0179-rt-reflection-ClinitFieldSetIntInterface │ │ │ └── ClassInitFieldSetIntInterface.java │ │ ├── RT0180-rt-reflection-ClinitFieldSetLongInterface │ │ │ └── ClassInitFieldSetLongInterface.java │ │ ├── RT0181-rt-reflection-ClinitFieldSetShortInterface │ │ │ └── ClassInitFieldSetShortInterface.java │ │ ├── RT0182-rt-reflection-ClinitMethodInvokeInterface │ │ │ └── ClassInitMethodInvokeInterface.java │ │ ├── RT0184-rt-reflection-MethodTest │ │ │ └── MethodTest.java │ │ ├── RT0186-rt-reflection-ConstructorTest │ │ │ └── ConstructorTest.java │ │ ├── RT0188-rt-reflection-MethodHandleReflectCombineTest │ │ │ └── MethodHandleReflectCombineTest.java │ │ ├── RT0189-rt-reflection-FieldTest │ │ │ └── FieldTest.java │ │ ├── RT0200-rt-reflection-AnnotationTypeParameterSetTest │ │ │ ├── AnnoA.java │ │ │ ├── AnnoB.java │ │ │ └── AnnotationTypeParameterSetTest.java │ │ ├── RT0201-rt-reflection-AnnotationTypeUseSetTest │ │ │ ├── AnnoA.java │ │ │ ├── AnnoB.java │ │ │ └── AnnotationTypeUseSetTest.java │ │ ├── RT0202-rt-reflection-AnnotationMultiThread │ │ │ ├── AnnoA.java │ │ │ ├── AnnoB.java │ │ │ ├── AnnoC.java │ │ │ ├── AnnoD.java │ │ │ ├── AnnotationMultiThread.java │ │ │ └── ENUMA.java │ │ ├── RT0208-rt-reflection-MetadataCheck │ │ │ ├── FieldTest.java │ │ │ └── MethodTest.java │ │ ├── issue-0000-rt-Reflection-ReflectionforName2 │ │ │ └── ReflectionForName2.java │ │ ├── issue-RT0893-rt-Reflection-ClinitFieldSetCharInterface │ │ │ └── ClassInitFieldSetCharInterface.java │ │ └── issue-RT0894-rt-Reflection-ClinitFieldSetDoubleInterface │ │ │ └── ClassInitFieldSetDoubleInterface.java │ ├── stmtpre_test │ │ ├── RT0001-rt-String-StmtTest01 │ │ │ └── StmtTest01.java │ │ ├── RT0002-rt-String-StmtTest02 │ │ │ └── StmtTest02.java │ │ ├── RT0003-rt-String-StmtTest03 │ │ │ └── StmtTest03.java │ │ ├── RT0004-rt-String-StmtTest04 │ │ │ └── StmtTest04.java │ │ ├── RT0005-rt-String-StmtTest05 │ │ │ └── StmtTest05.java │ │ ├── RT0006-rt-String-StmtTest06 │ │ │ └── StmtTest06.java │ │ ├── RT0007-rt-String-StmtTest07 │ │ │ └── StmtTest07.java │ │ ├── RT0008-rt-String-StmtTest08 │ │ │ └── StmtTest08.java │ │ ├── RT0009-rt-String-StmtTest09 │ │ │ └── StmtTest09.java │ │ ├── RT0010-rt-String-StmtTest10 │ │ │ └── StmtTest10.java │ │ ├── RT0011-rt-String-StmtTest11 │ │ │ └── StmtTest11.java │ │ ├── RT0013-rt-String-StmtTest13 │ │ │ └── StmtTest13.java │ │ └── RT0014-rt-String-StmtTest14 │ │ │ └── StmtTest14.java │ ├── string_test │ │ ├── RT0001-rt-string-ReflectString │ │ │ └── ReflectString.java │ │ ├── RT0002-rt-String-BufferConstructorsTest │ │ │ └── StringBufferConstructorsTest.java │ │ ├── RT0003-rt-String-BufferAppendAndAppendCodePointTest │ │ │ └── StringBufferAppendAndAppendCodePointTest.java │ │ ├── RT0004-rt-String-BufferInsertTest │ │ │ └── StringBufferInsertTest.java │ │ ├── RT0005-rt-String-BufferDeleteAndDeleteCharAtTest │ │ │ └── StringBufferDeleteAndDeleteCharAtTest.java │ │ ├── RT0006-rt-String-BufferCodePointExceptionTest │ │ │ └── StringBufferCodePointExceptionTest.java │ │ ├── RT0007-rt-String-BufferCapacityAndEnsureCapacityTest │ │ │ └── StringBufferCapacityAndEnsureCapacityTest.java │ │ ├── RT0008-rt-String-BufferCharAtAndSetCharAtExceptionTest │ │ │ └── StringBufferCharAtAndSetCharAtExceptionTest.java │ │ ├── RT0009-rt-String-BufferGetCharsTest │ │ │ └── StringBufferGetCharsTest.java │ │ ├── RT0010-rt-String-BufferIndexOfAndLastIndexOfTest │ │ │ └── StringBufferIndexOfAndLastIndexOfTest.java │ │ ├── RT0011-rt-String-BufferReplaceAndReverseTest │ │ │ └── StringBufferReplaceAndReverseTest.java │ │ ├── RT0012-rt-String-BufferSubstringAndToStringTest │ │ │ └── StringBufferSubstringAndToStringTest.java │ │ ├── RT0013-rt-String-BuilderConstructorsTest │ │ │ └── StringBuilderConstructorsTest.java │ │ ├── RT0014-rt-String-BuilderAppendAndAppendCodePointTest │ │ │ └── StringBuilderAppendAndAppendCodePointTest.java │ │ ├── RT0015-rt-String-BuilderInsertTest │ │ │ └── StringBuilderInsertTest.java │ │ ├── RT0016-rt-String-BuilderDeleteAndDeleteCharAtTest │ │ │ └── StringBuilderDeleteAndDeleteCharAtTest.java │ │ ├── RT0017-rt-String-BuilderCodePointExceptionTest │ │ │ └── StringBuilderCodePointExceptionTest.java │ │ ├── RT0018-rt-String-BuilderCapacityAndEnsureCapacityTest │ │ │ └── StringBuilderCapacityAndEnsureCapacityTest.java │ │ ├── RT0019-rt-String-BuilderCharAtAndSetCharAtExceptionTest │ │ │ └── StringBuilderCharAtAndSetCharAtExceptionTest.java │ │ ├── RT0020-rt-String-BuilderGetCharsTest │ │ │ └── StringBuilderGetCharsTest.java │ │ ├── RT0021-rt-String-BuilderIndexOfAndLastIndexOfTest │ │ │ └── StringBuilderIndexOfAndLastIndexOfTest.java │ │ ├── RT0022-rt-String-BuilderReplaceAndReverseTest │ │ │ └── StringBuilderReplaceAndReverseTest.java │ │ ├── RT0023-rt-String-BuilderSubstringAndToStringTest │ │ │ └── StringBuilderSubstringAndToStringTest.java │ │ ├── RT0024-rt-String-ConsBytesIntIntIndexOutOfBoundsExceptionTest │ │ │ └── StringConsBytesIntIntIndexOutOfBoundsExceptionTest.java │ │ ├── RT0025-rt-String-ConsCharArrayIndexOutOfBoundsExceptionTest │ │ │ └── StringConsCharArrayIndexOutOfBoundsExceptionTest.java │ │ ├── RT0026-rt-String-ConsIntArrayExceptionsTest │ │ │ └── StringConsIntArrayExceptionsTest.java │ │ ├── RT0027-rt-String-ConsBytesIntIntIntIndexOutOfBoundsExceptionTest │ │ │ └── StringConsBytesIntIntIntIndexOutOfBoundsExceptionTest.java │ │ ├── RT0028-rt-String-ConsBytesIntIntCharsetExceptionTest │ │ │ └── StringConsBytesIntIntCharsetExceptionTest.java │ │ ├── RT0029-rt-String-CharAtIndexOutOfBoundsExceptionTest │ │ │ └── StringCharAtIndexOutOfBoundsExceptionTest.java │ │ ├── RT0030-rt-String-CodePointAtStringIndexOutOfBoundsExceptionTest │ │ │ └── StringCodePointAtStringIndexOutOfBoundsExceptionTest.java │ │ ├── RT0031-rt-String-CodePointBeforeExceptionTest │ │ │ └── StringCodePointBeforeExceptionTest.java │ │ ├── RT0032-rt-String-CodePointCountIndexOutOfBoundsExceptionTest │ │ │ └── StringCodePointCountIndexOutOfBoundsExceptionTest.java │ │ ├── RT0033-rt-String-OffsetByCodePointsIndexOutOfBoundsExceptionTest │ │ │ └── StringOffsetByCodePointsIndexOutOfBoundsExceptionTest.java │ │ ├── RT0034-rt-String-GetCharsExceptionsTest │ │ │ └── StringGetCharsExceptionsTest.java │ │ ├── RT0035-rt-String-GetBytesExceptionTest │ │ │ └── StringGetBytesExceptionTest.java │ │ ├── RT0036-rt-String-SubstringStringIndexOutOfBoundsExceptionTest │ │ │ └── StringSubstringStringIndexOutOfBoundsExceptionTest.java │ │ ├── RT0037-rt-String-SubstringIntIntExceptionTest │ │ │ └── StringSubstringIntIntExceptionTest.java │ │ ├── RT0038-rt-String-SubSequenceIndexOutOfBoundsExceptionTest │ │ │ └── StringSubSequenceIndexOutOfBoundsExceptionTest.java │ │ ├── RT0039-rt-String-ReplaceNullPointerExceptionTest │ │ │ └── StringReplaceNullPointerExceptionTest.java │ │ ├── RT0040-rt-String-ValueOfAndCopyValueOfExceptionTest │ │ │ └── StringValueOfAndCopyValueOfExceptionTest.java │ │ ├── RT0041-rt-String-GetClassTest │ │ │ └── StringGetClassTest.java │ │ ├── RT0042-rt-String-EqualsAndEqualsIgnoreCaseAndLengthTest │ │ │ └── StringEqualsAndEqualsIgnoreCaseAndLengthTest.java │ │ ├── RT0043-rt-String-NoParamConstructorTest │ │ │ └── StringNoParamConstructorTest.java │ │ ├── RT0044-rt-String-ConsStringTest │ │ │ └── StringConsStringTest.java │ │ ├── RT0045-rt-String-ConsCharTest │ │ │ └── StringConsCharTest.java │ │ ├── RT0046-rt-String-ConsCharIntIntTest │ │ │ └── StringConsCharIntIntTest.java │ │ ├── RT0047-rt-String-ConsIntsIntIntTest │ │ │ └── StringConsIntsIntIntTest.java │ │ ├── RT0048-rt-String-ConsBytesIntTest │ │ │ └── StringConsBytesIntTest.java │ │ ├── RT0049-rt-String-ConsBytesIntIntStringTest │ │ │ └── StringConsBytesIntIntStringTest.java │ │ ├── RT0050-rt-String-CosBytesIntIntCharsetTest │ │ │ └── StringCosBytesIntIntCharsetTest.java │ │ ├── RT0051-rt-String-ConsBytesStringTest │ │ │ └── StringConsBytesStringTest.java │ │ ├── RT0052-rt-String-ConsBytesCharsetTest │ │ │ └── StringConsBytesCharsetTest.java │ │ ├── RT0053-rt-String-ConsBytesIntIntTest │ │ │ └── StringConsBytesIntIntTest.java │ │ ├── RT0054-rt-String-ConsBytesTest │ │ │ └── StringConsBytesTest.java │ │ ├── RT0055-rt-String-ConsStringBufferTest │ │ │ └── StringConsStringBufferTest.java │ │ ├── RT0056-rt-String-ConsStringBuilderTest │ │ │ └── StringConsStringBuilderTest.java │ │ ├── RT0057-rt-String-LengthTest │ │ │ └── StringLengthTest.java │ │ ├── RT0058-rt-String-IsEmptyTest │ │ │ └── StringIsEmptyTest.java │ │ ├── RT0059-rt-String-CharAtTest │ │ │ └── StringCharAtTest.java │ │ ├── RT0060-rt-String-CodePointAtTest │ │ │ └── StringCodePointAtTest.java │ │ ├── RT0061-rt-String-CodePointBeforeTest │ │ │ └── StringCodePointBeforeTest.java │ │ ├── RT0062-rt-String-CodePointCountTest │ │ │ └── StringCodePointCountTest.java │ │ ├── RT0063-rt-String-OffsetByCodePointsTest │ │ │ └── StringOffsetByCodePointsTest.java │ │ ├── RT0064-rt-String-GetCharsTest │ │ │ └── StringGetCharsTest.java │ │ ├── RT0065-rt-String-GetBytesIntIntBytesIntTest │ │ │ └── StringGetBytesIntIntBytesIntTest.java │ │ ├── RT0066-rt-String-GetBytesStringTest │ │ │ └── StringGetBytesStringTest.java │ │ ├── RT0067-rt-String-GetBytesCharsetTest │ │ │ └── StringGetBytesCharsetTest.java │ │ ├── RT0068-rt-String-GetBytesTest │ │ │ └── StringGetBytesTest.java │ │ ├── RT0069-rt-String-EqualsTest │ │ │ └── StringEqualsTest.java │ │ ├── RT0070-rt-String-ContentEqualsTest │ │ │ └── StringContentEqualsTest.java │ │ ├── RT0071-rt-String-ContentEqualsCharSequenceTest │ │ │ └── StringContentEqualsCharSequenceTest.java │ │ ├── RT0072-rt-String-EqualsIgnoreCaseTest │ │ │ └── StringEqualsIgnoreCaseTest.java │ │ ├── RT0073-rt-String-CompareToTest │ │ │ └── StringCompareToTest.java │ │ ├── RT0074-rt-String-CompareToIgnoreCaseTest │ │ │ └── StringCompareToIgnoreCaseTest.java │ │ ├── RT0075-rt-String-RegionMatchesIntStringIntIntTest │ │ │ └── StringRegionMatchesIntStringIntIntTest.java │ │ ├── RT0076-rt-String-RegionMatchesBooleanIntStringIntIntTest │ │ │ └── StringRegionMatchesBooleanIntStringIntIntTest.java │ │ ├── RT0077-rt-String-StartsWithStringIntTest │ │ │ └── StringStartsWithStringIntTest.java │ │ ├── RT0078-rt-String-StartsWithStringTest │ │ │ └── StringStartsWithStringTest.java │ │ ├── RT0079-rt-String-EndsWithTest │ │ │ └── StringEndsWithTest.java │ │ ├── RT0080-rt-String-HashCodeTest │ │ │ └── StringHashCodeTest.java │ │ ├── RT0081-rt-String-IndexOfIntTest │ │ │ └── StringIndexOfIntTest.java │ │ ├── RT0082-rt-String-IndexOfIntIntTest │ │ │ └── StringIndexOfIntIntTest.java │ │ ├── RT0083-rt-String-LastIndexOfIntTest │ │ │ └── StringLastIndexOfIntTest.java │ │ ├── RT0084-rt-String-LastIndexOfIntIntTest │ │ │ └── StringLastIndexOfIntIntTest.java │ │ ├── RT0085-rt-String-IndexOfStringTest │ │ │ └── StringIndexOfStringTest.java │ │ ├── RT0086-rt-String-IndexOfStringIntTest │ │ │ └── StringIndexOfStringIntTest.java │ │ ├── RT0087-rt-String-LastIndexOfStringTest │ │ │ └── StringLastIndexOfStringTest.java │ │ ├── RT0088-rt-String-LastIndexOfStringIntTest │ │ │ └── StringLastIndexOfStringIntTest.java │ │ ├── RT0089-rt-String-SubstringIntTest │ │ │ └── StringSubstringIntTest.java │ │ ├── RT0090-rt-String-SubstringIntIntTest │ │ │ └── StringSubstringIntIntTest.java │ │ ├── RT0091-rt-String-SubSequenceIntIntTest │ │ │ └── StringSubSequenceIntIntTest.java │ │ ├── RT0092-rt-String-ConcatTest │ │ │ └── StringConcatTest.java │ │ ├── RT0093-rt-String-ReplaceCharCharTest │ │ │ └── StringReplaceCharCharTest.java │ │ ├── RT0094-rt-String-ContainsTest │ │ │ └── StringContainsTest.java │ │ ├── RT0095-rt-String-ReplaceCharSequenceCharSequenceTest │ │ │ └── StringReplaceCharSequenceCharSequenceTest.java │ │ ├── RT0096-rt-String-SplitStringIntTest │ │ │ └── StringSplitStringIntTest.java │ │ ├── RT0097-rt-String-SplitStringTest │ │ │ └── StringSplitStringTest.java │ │ ├── RT0098-rt-String-JoinCharSequenceCharSequenceTest │ │ │ └── StringJoinCharSequenceCharSequenceTest.java │ │ ├── RT0099-rt-String-JoinCharSequenceIterableTest │ │ │ └── StringJoinCharSequenceIterableTest.java │ │ ├── RT0100-rt-String-ToLowerCaseLocaleTest │ │ │ └── StringToLowerCaseLocaleTest.java │ │ ├── RT0101-rt-String-ToLowerCaseTest │ │ │ └── StringToLowerCaseTest.java │ │ ├── RT0102-rt-String-ToUpperCaseLocaleTest │ │ │ └── StringToUpperCaseLocaleTest.java │ │ ├── RT0103-rt-String-ToUpperCaseTest │ │ │ └── StringToUpperCaseTest.java │ │ ├── RT0104-rt-String-TrimTest │ │ │ └── StringTrimTest.java │ │ ├── RT0105-rt-String-ToStringTest │ │ │ └── StringToStringTest.java │ │ ├── RT0106-rt-String-ToCharArrayTest │ │ │ └── StringToCharArrayTest.java │ │ ├── RT0107-rt-String-FormatStringObjectTest │ │ │ └── StringFormatStringObjectTest.java │ │ ├── RT0108-rt-String-ValueOfObjectTest │ │ │ └── StringValueOfObjectTest.java │ │ ├── RT0109-rt-String-ValueOfCharsTest │ │ │ └── StringValueOfCharsTest.java │ │ ├── RT0110-rt-String-ValueOfCharIntIntTest │ │ │ └── StringValueOfCharIntIntTest.java │ │ ├── RT0111-rt-String-CopyValueOfCharIntIntTest │ │ │ └── StringCopyValueOfCharIntIntTest.java │ │ ├── RT0112-rt-String-CopyValueOfCharTest │ │ │ └── StringCopyValueOfCharTest.java │ │ ├── RT0113-rt-String-ValueOfBooleanTest │ │ │ └── StringValueOfBooleanTest.java │ │ ├── RT0114-rt-String-ValueOfCharTest │ │ │ └── StringValueOfCharTest.java │ │ ├── RT0115-rt-String-ValueOfIntTest │ │ │ └── StringValueOfIntTest.java │ │ ├── RT0116-rt-String-ValueOfLongTest │ │ │ └── StringValueOfLongTest.java │ │ ├── RT0117-rt-String-ValueOfFloatTest │ │ │ └── StringValueOfFloatTest.java │ │ ├── RT0118-rt-String-ValueOfDoubleTest │ │ │ └── StringValueOfDoubleTest.java │ │ ├── RT0119-rt-String-InternTest │ │ │ └── StringInternTest.java │ │ ├── RT0120-rt-String-VoluationTest │ │ │ └── StringVoluationTest.java │ │ ├── RT0121-rt-String-VoluationCharsTest │ │ │ └── StringVoluationCharsTest.java │ │ ├── RT0122-rt-String-SpliceStringTest │ │ │ └── StringSpliceStringTest.java │ │ ├── RT0123-rt-String-CompareByDoubleEqualSignTest │ │ │ └── StringCompareByDoubleEqualSignTest.java │ │ ├── RT0124-rt-String-CompareByEqualsTest │ │ │ └── StringCompareByEqualsTest.java │ │ ├── RT0125-rt-String-ConvertToByteTest │ │ │ └── StringConvertToByteTest.java │ │ ├── RT0126-rt-String-ConvertToShortTest │ │ │ └── StringConvertToShortTest.java │ │ ├── RT0127-rt-String-ConvertToIntTest │ │ │ └── StringConvertToIntTest.java │ │ ├── RT0128-rt-String-ConvertToLongTest │ │ │ └── StringConvertToLongTest.java │ │ ├── RT0129-rt-String-ConvertToFloatTest │ │ │ └── StringConvertToFloatTest.java │ │ ├── RT0130-rt-String-ConvertToDoubleTest │ │ │ └── StringConvertToDoubleTest.java │ │ ├── RT0131-rt-String-LongToBinaryStringTest │ │ │ └── LongToBinaryStringTest.java │ │ ├── RT0132-rt-String-LongToOctalStringTest │ │ │ └── LongToOctalStringTest.java │ │ ├── RT0133-rt-String-BasicToStringTest │ │ │ └── BasicToStringTest.java │ │ ├── RT0134-rt-String-NullToStringTest │ │ │ └── NullToStringTest.java │ │ ├── RT0135-rt-String-AsciiToStringTest │ │ │ └── AsciiToStringTest.java │ │ ├── RT0136-rt-String-ToHexStringCharTest │ │ │ └── StringToHexStringCharTest.java │ │ ├── RT0137-rt-String-AsVariableAndFieldAndParamTest │ │ │ └── StringAsVariableAndFieldAndParamTest.java │ │ ├── RT0138-rt-String-VariableOfInterfaceTest │ │ │ └── StringVariableOfInterfaceTest.java │ │ ├── RT0139-rt-String-CreateStringArrayTest │ │ │ └── StringCreateStringArrayTest.java │ │ ├── RT0140-rt-String-GenericTest │ │ │ └── StringGenericTest.java │ │ ├── RT0141-rt-String-MultiThreadsTest │ │ │ └── StringMultiThreadsTest.java │ │ ├── RT0142-rt-String-JoinNullPointerExceptionTest │ │ │ └── StringJoinNullPointerExceptionTest.java │ │ ├── RT0143-rt-String-NullPointExceptionTest │ │ │ └── StringNullPointExceptionTest.java │ │ ├── RT0144-rt-String-BufferExceptionsTest │ │ │ └── StringBufferExceptionsTest.java │ │ ├── RT0145-rt-String-BuilderExceptionsTest │ │ │ └── StringBuilderExceptionsTest.java │ │ ├── RT0146-rt-String-ClassNewInstanceTest │ │ │ └── StringClassNewInstanceTest.java │ │ ├── RT0147-rt-String-PoolEnlargeTest │ │ │ └── StringPoolEnlargeTest.java │ │ ├── RT0148-rt-String-XByteTest │ │ │ └── StringXByteTest.java │ │ ├── RT0149-rt-String-ClassNewInstance2Test │ │ │ └── StringClassNewInstance2Test.java │ │ ├── RT0150-rt-String-Emoji │ │ │ └── StringEmojiTest.java │ │ ├── issue-0000-rt-String-StringGetBytesUnsupportedEncodingExceptionTest │ │ │ └── StringGetBytesUnsupportedEncodingExceptionTest.java │ │ ├── issue-0000-rt-String-StringStringIndexOutOfBoundsExceptionTest │ │ │ └── StringStringIndexOutOfBoundsExceptionTest.java │ │ ├── issue-0000-rt-String-StringUnsupportedEncodingExceptionTest │ │ │ └── StringUnsupportedEncodingExceptionTest.java │ │ ├── issue-0000-rt-String-StringUserCaseLiteralsISO88591Test │ │ │ └── StringUserCaseLiteralsISO88591Test.java │ │ └── issue-RT0818-rt-String-StringOOMTest │ │ │ └── StringOOMTest.java │ ├── subsumeRC_test │ │ ├── RT0001-rt-compiler-LiverangeSubsumeRCTest01 │ │ │ └── LiverangeSubsumeRCTest01.java │ │ ├── RT0002-rt-compiler-LiverangeSubsumeRCTest02 │ │ │ └── LiverangeSubsumeRCTest02.java │ │ ├── RT0003-rt-compiler-LiverangeSubsumeRCTest03 │ │ │ └── LiverangeSubsumeRCTest03.java │ │ ├── RT0004-rt-compiler-LiverangeSubsumeRCTest04 │ │ │ └── LiverangeSubsumeRCTest04.java │ │ ├── RT0005-rt-compiler-LiverangeSubsumeRCTest05 │ │ │ └── LiverangeSubsumeRCTest05.java │ │ ├── RT0006-rt-compiler-LiverangeSubsumeRCTest06 │ │ │ └── LiverangeSubsumeRCTest06.java │ │ ├── RT0007-rt-compiler-LiverangeSubsumeRCTest07 │ │ │ └── LiverangeSubsumeRCTest07.java │ │ ├── RT0008-rt-compiler-LiverangeSubsumeRCTest08 │ │ │ └── LiverangeSubsumeRCTest08.java │ │ ├── RT0009-rt-compiler-LiverangeSubsumeRCTest09 │ │ │ └── LiverangeSubsumeRCTest09.java │ │ ├── RT0010-rt-compiler-LiverangeSubsumeRCTest10 │ │ │ └── LiverangeSubsumeRCTest10.java │ │ ├── RT0011-rt-compiler-LiverangeSubsumeRCTest11 │ │ │ └── LiverangeSubsumeRCTest11.java │ │ ├── RT0012-rt-compiler-LiverangeSubsumeRCTest12 │ │ │ └── LiverangeSubsumeRCTest12.java │ │ ├── RT0013-rt-compiler-LiverangeSubsumeRCTest13 │ │ │ └── LiverangeSubsumeRCTest13.java │ │ └── RT0014-rt-compiler-LiverangeSubsumeRCTest14 │ │ │ └── LiverangeSubsumeRCTest14.java │ ├── test.cfg │ ├── testlist │ ├── thread_test │ │ ├── RT0001-rt-thread-ThreadactiveCount │ │ │ └── ThreadActiveCount.java │ │ ├── RT0002-rt-thread-ThreadcheckAccess │ │ │ └── ThreadCheckAccess.java │ │ ├── RT0003-rt-thread-Threadclone │ │ │ └── ThreadClone.java │ │ ├── RT0004-rt-thread-ThreadConstructors1 │ │ │ └── ThreadConstructors1.java │ │ ├── RT0005-rt-thread-ThreadConstructors10 │ │ │ └── ThreadConstructors10.java │ │ ├── RT0006-rt-thread-ThreadConstructors2 │ │ │ └── ThreadConstructors2.java │ │ ├── RT0007-rt-thread-ThreadConstructors3 │ │ │ └── ThreadConstructors3.java │ │ ├── RT0008-rt-thread-ThreadConstructors4 │ │ │ └── ThreadConstructors4.java │ │ ├── RT0009-rt-thread-ThreadConstructors5 │ │ │ └── ThreadConstructors5.java │ │ ├── RT0010-rt-thread-ThreadConstructors6 │ │ │ └── ThreadConstructors6.java │ │ ├── RT0011-rt-thread-ThreadConstructors7 │ │ │ └── ThreadConstructors7.java │ │ ├── RT0012-rt-thread-ThreadConstructors8 │ │ │ └── ThreadConstructors8.java │ │ ├── RT0013-rt-thread-ThreadConstructors9 │ │ │ └── ThreadConstructors9.java │ │ ├── RT0014-rt-thread-ThreadcurrentThread │ │ │ └── ThreadCurrentThread.java │ │ ├── RT0015-rt-thread-ThreadDMcountStackFrames1 │ │ │ └── ThreadDMCountStackFrames1.java │ │ ├── RT0016-rt-thread-ThreadDMcountStackFrames2 │ │ │ └── ThreadDMCountStackFrames2.java │ │ ├── RT0017-rt-thread-ThreadDMdestroy │ │ │ └── ThreadDMDestroy.java │ │ ├── RT0018-rt-thread-ThreadDMresume │ │ │ └── ThreadDMResume.java │ │ ├── RT0019-rt-thread-ThreadDMstop │ │ │ └── ThreadDMStop.java │ │ ├── RT0020-rt-thread-ThreadDMstopTh │ │ │ └── ThreadDMStopThrowable.java │ │ ├── RT0021-rt-thread-ThreadDMsuspend │ │ │ └── ThreadDMSuspend.java │ │ ├── RT0022-rt-thread-Threadenumerate │ │ │ └── ThreadEnumerate.java │ │ ├── RT0023-rt-thread-Threadextends1 │ │ │ └── ThreadExtends1.java │ │ ├── RT0024-rt-thread-Threadextends2 │ │ │ └── ThreadExtends2.java │ │ ├── RT0025-rt-thread-ThreadgetDefaultUncaughtExceptionHandler1 │ │ │ └── ThreadGetDefaultUncaughtExceptionHandler1.java │ │ ├── RT0026-rt-thread-ThreadgetDefaultUncaughtExceptionHandler2 │ │ │ └── ThreadGetDefaultUncaughtExceptionHandler2.java │ │ ├── RT0027-rt-thread-ThreadgetId │ │ │ └── ThreadGetId.java │ │ ├── RT0028-rt-thread-ThreadgetName │ │ │ └── ThreadGetName.java │ │ ├── RT0029-rt-thread-ThreadgetPriority │ │ │ └── ThreadGetPriority.java │ │ ├── RT0030-rt-thread-ThreadgetThreadGroup1 │ │ │ └── ThreadGetThreadGroup1.java │ │ ├── RT0031-rt-thread-ThreadgetThreadGroup2 │ │ │ └── ThreadGetThreadGroup2.java │ │ ├── RT0032-rt-thread-ThreadgetUncaughtExceptionHandler1 │ │ │ └── ThreadGetUncaughtExceptionHandler1.java │ │ ├── RT0033-rt-thread-ThreadgetUncaughtExceptionHandler2 │ │ │ └── ThreadGetUncaughtExceptionHandler2.java │ │ ├── RT0034-rt-thread-ThreadgetUncaughtExceptionHandler3 │ │ │ └── ThreadGetUncaughtExceptionHandler3.java │ │ ├── RT0035-rt-thread-ThreadholdsLock1 │ │ │ └── ThreadHoldsLock1.java │ │ ├── RT0036-rt-thread-ThreadholdsLock2 │ │ │ └── ThreadHoldsLock2.java │ │ ├── RT0037-rt-thread-ThreadholdsLock3 │ │ │ └── ThreadHoldsLock3.java │ │ ├── RT0038-rt-thread-ThreadisAlive1 │ │ │ └── ThreadIsAlive1.java │ │ ├── RT0039-rt-thread-ThreadisAlive2 │ │ │ └── ThreadIsAlive2.java │ │ ├── RT0040-rt-thread-ThreadisAlive3 │ │ │ └── ThreadIsAlive3.java │ │ ├── RT0041-rt-thread-ThreadisDaemon1 │ │ │ └── ThreadIsDaemon1.java │ │ ├── RT0042-rt-thread-ThreadisDaemon2 │ │ │ └── ThreadIsDaemon2.java │ │ ├── RT0043-rt-thread-ThreadRunnable │ │ │ └── ThreadRunnable.java │ │ ├── RT0044-rt-thread-ThreadsetDaemon1 │ │ │ └── ThreadSetDaemon1.java │ │ ├── RT0045-rt-thread-ThreadsetDaemon2 │ │ │ └── ThreadSetDaemon2.java │ │ ├── RT0046-rt-thread-ThreadsetDaemon3 │ │ │ └── ThreadSetDaemon3.java │ │ ├── RT0047-rt-thread-ThreadsetDefaultUncaughtExceptionHandler │ │ │ └── ThreadSetDefaultUncaughtExceptionHandler.java │ │ ├── RT0048-rt-thread-ThreadsetName1 │ │ │ └── ThreadSetName1.java │ │ ├── RT0049-rt-thread-ThreadsetName2 │ │ │ └── ThreadSetName2.java │ │ ├── RT0050-rt-thread-ThreadsetPriority1 │ │ │ └── ThreadSetPriority1.java │ │ ├── RT0051-rt-thread-ThreadsetPriority2 │ │ │ └── ThreadSetPriority2.java │ │ ├── RT0052-rt-thread-ThreadsetPriority3 │ │ │ └── ThreadsSetPriority3.java │ │ ├── RT0053-rt-thread-ThreadsetPriority4 │ │ │ └── ThreadSetPriority4.java │ │ ├── RT0054-rt-thread-ThreadsetPriority5 │ │ │ └── ThreadSetPriority5.java │ │ ├── RT0055-rt-thread-ThreadsetPriority6 │ │ │ └── ThreadSetPriority6.java │ │ ├── RT0056-rt-thread-ThreadsetPriority7 │ │ │ └── ThreadSetPriority7.java │ │ ├── RT0057-rt-thread-ThreadsetUncaughtExceptionHandler │ │ │ └── ThreadSetUncaughtExceptionHandler.java │ │ ├── RT0058-rt-thread-ThreadStateinterrupt1 │ │ │ └── ThreadStateInterrupt1.java │ │ ├── RT0059-rt-thread-ThreadStateinterrupt2 │ │ │ └── ThreadStateInterrupt2.java │ │ ├── RT0060-rt-thread-ThreadStatejoin1 │ │ │ └── ThreadStateJoin1.java │ │ ├── RT0061-rt-thread-ThreadStatejoin11 │ │ │ └── ThreadStateJoin11.java │ │ ├── RT0062-rt-thread-ThreadStatejoin12 │ │ │ └── ThreadStateJoin12.java │ │ ├── RT0063-rt-thread-ThreadStatejoin13 │ │ │ └── ThreadStateJoin13.java │ │ ├── RT0064-rt-thread-ThreadStatejoin14 │ │ │ └── ThreadStateJoin14.java │ │ ├── RT0065-rt-thread-ThreadStatejoin15 │ │ │ └── ThreadStateJoin15.java │ │ ├── RT0066-rt-thread-ThreadStatejoin2 │ │ │ └── ThreadStateJoin2.java │ │ ├── RT0067-rt-thread-ThreadStatejoin3 │ │ │ └── ThreadStateJoin3.java │ │ ├── RT0068-rt-thread-ThreadStatejoin4 │ │ │ └── ThreadStateJoin4.java │ │ ├── RT0069-rt-thread-ThreadStatejoin5 │ │ │ └── ThreadStateJoin5.java │ │ ├── RT0070-rt-thread-ThreadStatejoin6 │ │ │ └── ThreadStateJoin6.java │ │ ├── RT0071-rt-thread-ThreadStatejoin7 │ │ │ └── ThreadStateJoin7.java │ │ ├── RT0072-rt-thread-ThreadStatejoin8 │ │ │ └── ThreadStateJoin8.java │ │ ├── RT0073-rt-thread-ThreadStatejoin9 │ │ │ └── ThreadStateJoin9.java │ │ ├── RT0074-rt-thread-ThreadStatenotify1 │ │ │ └── ThreadStateNotify1.java │ │ ├── RT0075-rt-thread-ThreadStatenotify2 │ │ │ └── ThreadStateNotify2.java │ │ ├── RT0076-rt-thread-ThreadStatenotifyAll1 │ │ │ └── ThreadStateNotifyAll1.java │ │ ├── RT0077-rt-thread-ThreadStatenotifyAll2 │ │ │ └── ThreadStateNotifyAll2.java │ │ ├── RT0078-rt-thread-ThreadStatesleep1 │ │ │ └── ThreadStateSleep1.java │ │ ├── RT0079-rt-thread-ThreadStatesleep2 │ │ │ └── ThreadStateSleep2.java │ │ ├── RT0080-rt-thread-ThreadStatesleep3 │ │ │ └── ThreadStateSleep3.java │ │ ├── RT0081-rt-thread-ThreadStatesleep4 │ │ │ └── ThreadStateSleep4.java │ │ ├── RT0082-rt-thread-ThreadStatesleep5 │ │ │ └── ThreadStateSleep5.java │ │ ├── RT0083-rt-thread-ThreadStatesleep6 │ │ │ └── ThreadStateSleep6.java │ │ ├── RT0084-rt-thread-ThreadStatestart1 │ │ │ └── ThreadStateStart1.java │ │ ├── RT0085-rt-thread-ThreadStatestart2 │ │ │ └── ThreadStateStart2.java │ │ ├── RT0086-rt-thread-ThreadStatewait1 │ │ │ └── ThreadStateWait1.java │ │ ├── RT0087-rt-thread-ThreadStatewait2 │ │ │ └── ThreadStateWait2.java │ │ ├── RT0088-rt-thread-ThreadStatewait3 │ │ │ └── ThreadStateWait3.java │ │ ├── RT0089-rt-thread-ThreadStatewait4 │ │ │ └── ThreadStateWait4.java │ │ ├── RT0090-rt-thread-ThreadStatewait5 │ │ │ └── ThreadStateWait5.java │ │ ├── RT0091-rt-thread-ThreadStatewait6 │ │ │ └── ThreadStateWait6.java │ │ ├── RT0092-rt-thread-ThreadStatewait7 │ │ │ └── ThreadStateWait7.java │ │ ├── RT0093-rt-thread-ThreadStatewait8 │ │ │ └── ThreadStateWait8.java │ │ ├── RT0094-rt-thread-ThreadStateyield │ │ │ └── ThreadStateyield.java │ │ ├── RT0095-rt-thread-ThreadtoString │ │ │ └── ThreadToString.java │ │ ├── RT0096-rt-thread-ThreadTest23 │ │ │ └── ThreadTest.java │ │ ├── RT0097-rt-thread-ThreadTest31 │ │ │ └── ThreadTest.java │ │ ├── RT0098-rt-thread-ThreadTest11 │ │ │ └── ThreadTest.java │ │ ├── RT0099-rt-thread-ThreadTest21 │ │ │ └── ThreadTest.java │ │ ├── RT0100-rt-thread-ThreadTest34 │ │ │ └── ThreadTest.java │ │ ├── RT0101-rt-thread-ThreadTest25 │ │ │ └── ThreadTest.java │ │ ├── RT0102-rt-thread-ThreadTest9 │ │ │ └── ThreadTest.java │ │ ├── RT0103-rt-thread-ThreadTest8 │ │ │ └── ThreadTest.java │ │ ├── RT0104-rt-thread-ThreadTest38 │ │ │ └── ThreadTest.java │ │ ├── RT0105-rt-thread-ThreadTest30 │ │ │ └── ThreadTest.java │ │ ├── RT0106-rt-thread-ThreadTest28 │ │ │ └── ThreadTest.java │ │ ├── RT0107-rt-thread-ThreadTest39 │ │ │ └── ThreadTest.java │ │ ├── RT0109-rt-thread-Basic │ │ │ └── Basic.java │ │ ├── RT0110-rt-thread-NullStackTrace │ │ │ └── NullStackTrace.java │ │ ├── RT0111-rt-thread-ThreadTest6 │ │ │ └── ThreadTest.java │ │ ├── RT0112-rt-thread-TestThreadId │ │ │ └── TestThreadId.java │ │ ├── RT0113-rt-thread-ImmutableLocal │ │ │ └── ImmutableLocal.java │ │ ├── RT0114-rt-thread-ThreadTest24 │ │ │ └── ThreadTest_24.java │ │ ├── RT0115-rt-thread-ThreadTest13 │ │ │ └── ThreadTest_13.java │ │ ├── RT0116-rt-thread-NullThreadName │ │ │ └── NullThreadName.java │ │ ├── RT0117-rt-thread-ThreadTest36 │ │ │ └── ThreadTest.java │ │ ├── RT0118-rt-thread-ThreadTest19 │ │ │ └── ThreadTest.java │ │ ├── RT0119-rt-thread-ThreadTest15 │ │ │ └── ThreadTest.java │ │ ├── RT0120-rt-thread-ThreadTest3 │ │ │ └── ThreadTest.java │ │ ├── RT0121-rt-thread-InitialValue │ │ │ └── InitialValue.java │ │ ├── RT0122-rt-thread-ThreadTest22 │ │ │ └── ThreadTest.java │ │ ├── RT0123-rt-thread-ThreadTest7 │ │ │ └── ThreadTest.java │ │ ├── RT0125-rt-thread-ThreadTest26 │ │ │ └── ThreadTest.java │ │ ├── RT0126-rt-thread-SetMaxPriority │ │ │ └── SetMaxPriority.java │ │ ├── RT0127-rt-thread-ThreadTest18 │ │ │ └── ThreadTest.java │ │ ├── RT0128-rt-thread-ThreadTest16 │ │ │ └── ThreadTest.java │ │ ├── RT0130-rt-thread-ThreadTest20 │ │ │ └── ThreadTest.java │ │ ├── RT0131-rt-thread-ThreadTest14 │ │ │ └── ThreadTest.java │ │ ├── RT0132-rt-thread-ThreadTest17 │ │ │ └── ThreadTest.java │ │ ├── RT0133-rt-thread-ThreadTest33 │ │ │ └── ThreadTest.java │ │ ├── RT0134-rt-thread-ThreadTest27 │ │ │ └── ThreadTest.java │ │ ├── RT0135-rt-thread-StartOOMTest │ │ │ └── StartOOMTest.java │ │ ├── RT0136-rt-thread-ThreadTest29 │ │ │ └── ThreadTest.java │ │ ├── RT0137-rt-thread-ThreadTest12 │ │ │ └── ThreadTest.java │ │ ├── RT0138-rt-thread-ThreadTest32 │ │ │ └── ThreadTest.java │ │ ├── RT0139-rt-thread-ThreadTest4 │ │ │ └── ThreadTest.java │ │ ├── RT0140-rt-thread-MainThreadTest │ │ │ └── MainThreadTest.java │ │ ├── RT0141-rt-thread-ThreadTest35 │ │ │ └── ThreadTest.java │ │ ├── RT0142-rt-thread-ThreadTest5 │ │ │ └── ThreadTest.java │ │ ├── RT0143-rt-thread-Daemon │ │ │ └── Daemon.java │ │ ├── RT0144-rt-thread-ThreadTest10 │ │ │ └── ThreadTest.java │ │ ├── RT0145-rt-thread-MemoryLeak │ │ │ └── MemoryLeak.java │ │ ├── RT0146-rt-thread-ThreadId │ │ │ └── ThreadId.java │ │ ├── RT0147-rt-thread-ThreadTest1 │ │ │ └── ThreadTest.java │ │ ├── RT0148-rt-thread-ThreadTest37 │ │ │ └── ThreadTest.java │ │ ├── RT0149-rt-thread-ThreadConstructors13 │ │ │ └── ThreadConstructors13.java │ │ ├── RT0150-rt-thread-ThreadConstructors14 │ │ │ └── ThreadConstructors14.java │ │ ├── RT0151-rt-thread-ThreadConstructors15 │ │ │ └── ThreadConstructors15.java │ │ ├── RT0152-rt-thread-ThreadConstructors16 │ │ │ └── ThreadConstructors16.java │ │ ├── RT0153-rt-thread-ThreadConstructors17 │ │ │ └── ThreadConstructors17.java │ │ ├── RT0154-rt-thread-ThreadEHcountStackFrames │ │ │ └── ThreadCountStackFramesTest.java │ │ ├── RT0155-rt-thread-ThreadEHdestroy │ │ │ └── ThreadDestroyUnsupportedOperationExceptionTest.java │ │ ├── RT0156-rt-thread-Threadenumerate2 │ │ │ └── Threadenumerate2.java │ │ ├── RT0158-rt-thread-ThreadgetStackTrace │ │ │ └── ThreadgetStackTrace.java │ │ ├── RT0159-rt-thread-ThreadGroupallowThreadSuspension │ │ │ └── ThreadGroupAllowThreadSuspensionTest.java │ │ ├── RT0160-rt-thread-ThreadGroupEHdestroy │ │ │ └── ThreadGroupEHdestroy.java │ │ ├── RT0161-rt-thread-ThreadholdsLock4 │ │ │ └── ThreadholdsLock4.java │ │ ├── RT0162-rt-thread-ThreadLocalEHwithInitial │ │ │ └── ThreadLocalEHwithInitial.java │ │ ├── RT0163-rt-thread-ThreadsetContextClassLoader1 │ │ │ └── ThreadsetContextClassLoader1.java │ │ ├── RT0164-rt-thread-ThreadsetDefaultUncaughtExceptionHandler2 │ │ │ └── ThreadSetDefaultUncaughtExceptionHandlerTest.java │ │ ├── RT0165-rt-thread-ThreadsetUncaughtExceptionHandler2 │ │ │ └── ThreadSetUncaughtExceptionHandlerTest.java │ │ ├── RT0166-rt-thread-ThreadStatejoin16 │ │ │ └── ThreadStatejoin16.java │ │ ├── RT0167-rt-thread-ThreadStatejoin17 │ │ │ └── ThreadStatejoin17.java │ │ ├── RT0168-rt-thread-ThreadStatesleep7 │ │ │ └── ThreadStatesleep7.java │ │ ├── RT0169-rt-thread-ThreadStatewait9 │ │ │ └── ThreadStatewait9.java │ │ ├── RT0170-rt-thread-ThreadStatewait10 │ │ │ └── ThreadStatewait10.java │ │ ├── RT0171-rt-thread-ThreadStatewait11 │ │ │ └── ThreadStatewait11.java │ │ ├── RT0172-rt-thread-ThreadStatewait12 │ │ │ └── ThreadStatewait12.java │ │ ├── RT0173-rt-thread-ThreadConstructors11 │ │ │ └── ThreadConstructors11.java │ │ ├── RT0174-rt-thread-ThreadConstructors12 │ │ │ └── ThreadConstructors12.java │ │ ├── RT0175-rt-thread-MonitorTestCase1 │ │ │ └── MonitorTestCase1.java │ │ ├── RT0176-rt-thread-MonitorTestCase2 │ │ │ └── MonitorTestCase2.java │ │ ├── RT0177-rt-thread-MonitorTestCase4 │ │ │ └── MonitorTestCase4.java │ │ ├── RT0178-rt-thread-MonitorTestCase5 │ │ │ └── MonitorTestCase5.java │ │ ├── RT0179-rt-thread-MonitorTestCase6 │ │ │ └── MonitorTestCase6.java │ │ ├── RT0180-rt-thread-MonitorTestCase8 │ │ │ └── MonitorTestCase8.java │ │ ├── RT0181-rt-thread-ThreadCountStackFrames │ │ │ └── ThreadCountStackFrames.java │ │ ├── RT0182-rt-thread-ThreadDMdestory2 │ │ │ └── ThreadDMdestory2.java │ │ ├── RT0183-rt-thread-ThreadGetContextClassLoader │ │ │ └── ThreadGetContextClassLoader.java │ │ ├── RT0184-rt-Thread-GenerifyStackTraces2 │ │ │ └── GenerifyStackTraces.java │ │ ├── RT0185-rt-Thread-GenerifyAllStackTraces │ │ │ └── GenerifyAllStackTraces.java │ │ ├── RT0186-rt-Thread-getAllStackTraces-RecursiveCall │ │ │ └── RecursiveCall.java │ │ ├── RT0188-rt-Thread-getAllStackTraces-NullStackTrace │ │ │ └── NullStackTrace.java │ │ ├── issue-0000-rt-Thread-ThreadOutofmemory │ │ │ └── ThreadOutOfMemoryTest.java │ │ ├── issue-RT0392-rt-Thread-Threadperformance1 │ │ │ └── ThreadPerformance1Test.java │ │ ├── issue-RT0427-rt-Thread-ThreadStatenew │ │ │ └── ThreadStateNewTest.java │ │ ├── issue-RT0475-rt-Thread-GenerifyStackTraces │ │ │ └── GenerifyStackTraces.java │ │ ├── issue-RT0508-rt-Thread-JGFSyncBench │ │ │ └── JGFSyncBench.java │ │ ├── issue-RT0577-rt-Thread-ThreadsetContextClassLoader2 │ │ │ └── ThreadSetContextClassLoader2.java │ │ └── issue-RT0579-rt-Thread-ThreadsetName3 │ │ │ └── ThreadSetName3Test.java │ └── unsafe_test │ │ ├── RT0001-rt-unsafe-UnsafegetIntVolatileTest │ │ └── UnsafegetIntVolatileTest.java │ │ ├── RT0002-rt-unsafe-UnsafeallocateMemoryTest │ │ └── UnsafeallocateMemoryTest.java │ │ ├── RT0003-rt-unsafe-UnsafearrayBaseOffsetTest │ │ └── UnsafearrayBaseOffsetTest.java │ │ ├── RT0004-rt-unsafe-UnsafearrayIndexScaleTest │ │ └── UnsafearrayIndexScaleTest.java │ │ ├── RT0005-rt-unsafe-UnsafecompareAndSwapIntTest │ │ └── UnsafecompareAndSwapIntTest.java │ │ ├── RT0006-rt-unsafe-UnsafecompareAndSwapLongTest │ │ └── UnsafecompareAndSwapLongTest.java │ │ ├── RT0007-rt-unsafe-UnsafecompareAndSwapObjectTest │ │ └── UnsafecompareAndSwapObjectTest.java │ │ ├── RT0008-rt-unsafe-UnsafecopyMemoryTest │ │ └── UnsafecopyMemoryTest.java │ │ ├── RT0009-rt-unsafe-UnsafefreeMemoryTest │ │ └── UnsafefreeMemoryTest.java │ │ ├── RT0010-rt-unsafe-UnsafegetAndAddIntTest │ │ └── UnsafegetAndAddIntTest.java │ │ ├── RT0011-rt-unsafe-UnsafegetAndAddLongTest │ │ └── UnsafegetAndAddLongTest.java │ │ ├── RT0012-rt-unsafe-UnsafegetAndSetIntTest │ │ └── UnsafegetAndSetIntTest.java │ │ ├── RT0013-rt-unsafe-UnsafegetAndSetLongTest │ │ └── UnsafegetAndSetLongTest.java │ │ ├── RT0014-rt-unsafe-UnsafegetAndSetObjectTest │ │ └── UnsafegetAndSetObjectTest.java │ │ ├── RT0015-rt-unsafe-UnsafegetBooleanTest │ │ └── UnsafegetBooleanTest.java │ │ ├── RT0016-rt-unsafe-UnsafegetCharByAddressTest │ │ └── UnsafegetCharByAddressTest.java │ │ ├── RT0017-rt-unsafe-UnsafegetCharTest │ │ └── UnsafegetCharTest.java │ │ ├── RT0018-rt-unsafe-UnsafegetDoubleByAddressTest │ │ └── UnsafegetDoubleByAddressTest.java │ │ ├── RT0019-rt-unsafe-UnsafegetDoubleTest │ │ └── UnsafegetDoubleTest.java │ │ ├── RT0020-rt-unsafe-UnsafegetFloatByAddressTest │ │ └── UnsafegetFloatByAddressTest.java │ │ ├── RT0021-rt-unsafe-UnsafegetFloatTest │ │ └── UnsafegetFloatTest.java │ │ ├── RT0022-rt-unsafe-UnsafegetIntByAddressTest │ │ └── UnsafegetIntByAddressTest.java │ │ ├── RT0023-rt-unsafe-UnsafegetIntTest │ │ └── UnsafegetIntTest.java │ │ ├── RT0024-rt-unsafe-UnsafegetLongTest │ │ └── UnsafegetLongTest.java │ │ ├── RT0025-rt-unsafe-UnsafegetLongVolatileTest │ │ └── UnsafegetLongVolatileTest.java │ │ ├── RT0026-rt-unsafe-UnsafegetObjectTest │ │ └── UnsafegetObjectTest.java │ │ ├── RT0027-rt-unsafe-UnsafegetObjectVolatileTest │ │ └── UnsafegetObjectVolatileTest.java │ │ ├── RT0028-rt-unsafe-UnsafegetShortByAddressTest │ │ └── UnsafegetShortByAddressTest.java │ │ ├── RT0029-rt-unsafe-UnsafegetShortTest │ │ └── UnsafegetShortTest.java │ │ ├── RT0030-rt-unsafe-UnsafeobjectFieldOffeset │ │ └── UnsafeobjectFieldOffeset.java │ │ ├── RT0032-rt-unsafe-UnsafeputBooleanTest │ │ └── UnsafeputBooleanTest.java │ │ ├── RT0033-rt-unsafe-UnsafeputByteByAddressTest │ │ └── UnsafeputByteByAddressTest.java │ │ ├── RT0034-rt-unsafe-UnsafeputByteTest │ │ └── UnsafeputByteTest.java │ │ ├── RT0035-rt-unsafe-UnsafeputCharTest │ │ └── UnsafeputCharTest.java │ │ ├── RT0036-rt-unsafe-UnsafeputDoubleTest │ │ └── UnsafeputDoubleTest.java │ │ ├── RT0037-rt-unsafe-UnsafeputFloatTest │ │ └── UnsafeputFloatTest.java │ │ ├── RT0038-rt-unsafe-UnsafeputIntTest │ │ └── UnsafeputIntTest.java │ │ ├── RT0039-rt-unsafe-UnsafeputIntVolatileTest │ │ └── UnsafeputIntVolatileTest.java │ │ ├── RT0040-rt-unsafe-UnsafeputLongTest │ │ └── UnsafeputLongTest.java │ │ ├── RT0041-rt-unsafe-UnsafeputLongVolatileTest │ │ └── UnsafeputLongVolatileTest.java │ │ ├── RT0042-rt-unsafe-UnsafeputObjectTest │ │ └── UnsafeputObjectTest.java │ │ ├── RT0043-rt-unsafe-UnsafeputObjectVolatileTest │ │ └── UnsafeputObjectVolatileTest.java │ │ ├── RT0044-rt-unsafe-UnsafeputOrderedIntTest │ │ └── UnsafeputOrderedIntTest.java │ │ ├── RT0045-rt-unsafe-UnsafeputOrderedLongTest │ │ └── UnsafeputOrderedLongTest.java │ │ ├── RT0046-rt-unsafe-UnsafeputOrderedObjectTest │ │ └── UnsafeputOrderedObjectTest.java │ │ ├── RT0047-rt-unsafe-UnsafeputShortTest │ │ └── UnsafeputShortTest.java │ │ ├── RT0048-rt-unsafe-UnsafesetMemoryTest │ │ └── UnsafesetMemoryTest.java │ │ ├── RT0850-rt-unsafe-UnsafegetByteTest │ │ └── UnsafegetByteTest.java │ │ ├── RT0909-rt-unsafe-UnsafegetLongByAddressTest │ │ └── UnsafegetLongByAddressTest.java │ │ └── issue-RT0935-rt-unsafe-UnsafeunparkTest │ │ └── UnsafeunparkTest.java │ └── qemu_run.py └── tools └── README /.gitignore: -------------------------------------------------------------------------------- 1 | tools/clang* 2 | tools/ninja* 3 | tools/gn* 4 | build/logs* 5 | libjava-core 6 | output 7 | 8 | -------------------------------------------------------------------------------- /.gn: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | # 4 | # OpenArkCompiler is licensed under the Mulan PSL v1. 5 | # You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | # You may obtain a copy of Mulan PSL v1 at: 7 | # 8 | # http://license.coscl.org.cn/MulanPSL 9 | # 10 | # THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | # FIT FOR A PARTICULAR PURPOSE. 13 | # See the Mulan PSL v1 for more details. 14 | # 15 | buildconfig = "//build/config/BUILDCONFIG.gn" 16 | -------------------------------------------------------------------------------- /build/build.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | # 3 | # Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 4 | # 5 | # OpenArkCompiler is licensed under the Mulan PSL v1. 6 | # You can use this software according to the terms and conditions of the Mulan PSL v1. 7 | # You may obtain a copy of Mulan PSL v1 at: 8 | # 9 | # http://license.coscl.org.cn/MulanPSL 10 | # 11 | # THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 12 | # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 13 | # FIT FOR A PARTICULAR PURPOSE. 14 | # See the Mulan PSL v1 for more details. 15 | # 16 | set -e 17 | source build/envsetup.sh 18 | make clean 19 | option=$@ 20 | logfile_name=$(date +"%Y-%m-%d-%H-%M-%S") 21 | logfile_path=${MAPLE_ROOT}/build/logs 22 | date_str=$(date "+%Y-%m-%d %H:%M:%S") 23 | echo "${date_str} INFO special log start" | tee ${logfile_path}/${logfile_name}.log 24 | if [ "x${option}" = "xDEBUG" ]; then 25 | make BUILD_TYPE=DEBUG | tee -a ${logfile_path}/${logfile_name}.log 26 | else 27 | make | tee -a ${logfile_path}/${logfile_name}.log 28 | fi 29 | date_str=$(date "+%Y-%m-%d %H:%M:%S") 30 | echo "${date_str} INFO special log end" | tee -a ${logfile_path}/${logfile_name}.log 31 | -------------------------------------------------------------------------------- /build/config.gni: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | # 4 | # OpenArkCompiler is licensed under the Mulan PSL v1. 5 | # You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | # You may obtain a copy of Mulan PSL v1 at: 7 | # 8 | # http://license.coscl.org.cn/MulanPSL 9 | # 10 | # THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | # FIT FOR A PARTICULAR PURPOSE. 13 | # See the Mulan PSL v1 for more details. 14 | # 15 | # Toolchain setup 16 | GN_C_COMPILER = "${MAPLE_ROOT}/tools/clang+llvm-8.0.0-x86_64-linux-gnu-ubuntu-16.04/bin/clang" 17 | GN_CXX_COMPILER = "${MAPLE_ROOT}/tools/clang+llvm-8.0.0-x86_64-linux-gnu-ubuntu-16.04/bin/clang++" 18 | GN_AR_COMPILER = "${MAPLE_ROOT}/tools/clang+llvm-8.0.0-x86_64-linux-gnu-ubuntu-16.04/bin/llvm-ar" 19 | LLVMINC = "${MAPLE_ROOT}/tools/clang+llvm-8.0.0-x86_64-linux-gnu-ubuntu-16.04/include" 20 | LLVMLIBDIR = "${MAPLE_ROOT}/tools/clang+llvm-8.0.0-x86_64-linux-gnu-ubuntu-16.04/lib" 21 | target_toolchain = "//build/toolchain:clang" 22 | set_default_toolchain(target_toolchain) 23 | 24 | # Cross compile 25 | GN_C_CROSS_COMPILER = "/usr/bin/aarch64-linux-gnu-gcc-5" 26 | GN_CXX_CROSS_COMPILER = "/usr/bin/aarch64-linux-gnu-g++-5" 27 | GN_AR_CROSS_COMPILER = "/usr/bin/aarch64-linux-gnu-ar" 28 | GN_RANLIB_CROSS_COMPILER = "/usr/bin/aarch64-linux-gnu-ranlib" 29 | -------------------------------------------------------------------------------- /build/core/genmplt.mk: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | # 4 | # OpenArkCompiler is licensed under the Mulan PSL v1. 5 | # You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | # You may obtain a copy of Mulan PSL v1 at: 7 | # 8 | # http://license.coscl.org.cn/MulanPSL 9 | # 10 | # THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | # FIT FOR A PARTICULAR PURPOSE. 13 | # See the Mulan PSL v1 for more details. 14 | # 15 | $(LIB_CORE_MPLT): $(JBC2MPL_BIN) $(LIB_CORE_JAR) 16 | $(JBC2MPL_BIN) -injar $(LIB_CORE_JAR) -output $(LIB_CORE_PATH) 17 | -------------------------------------------------------------------------------- /build/core/java2jar.mk: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | # 4 | # OpenArkCompiler is licensed under the Mulan PSL v1. 5 | # You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | # You may obtain a copy of Mulan PSL v1 at: 7 | # 8 | # http://license.coscl.org.cn/MulanPSL 9 | # 10 | # THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | # FIT FOR A PARTICULAR PURPOSE. 13 | # See the Mulan PSL v1 for more details. 14 | # 15 | $(APP_JAR): %.jar : %.java $(LIB_CORE_JAR) 16 | $(JAVA2JAR) $(APP_JAR) $(LIB_CORE_JAR) "$(wildcard *.java)" 17 | -------------------------------------------------------------------------------- /build/core/maple_test.mk: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | # 4 | # OpenArkCompiler is licensed under the Mulan PSL v1. 5 | # You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | # You may obtain a copy of Mulan PSL v1 at: 7 | # 8 | # http://license.coscl.org.cn/MulanPSL 9 | # 10 | # THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | # FIT FOR A PARTICULAR PURPOSE. 13 | # See the Mulan PSL v1 for more details. 14 | # 15 | include $(MAPLE_BUILD_CORE)/maple_variables.mk 16 | 17 | test: $(APP_S) 18 | include $(MAPLE_BUILD_CORE)/mplcomb.mk 19 | include $(MAPLE_BUILD_CORE)/genmplt.mk 20 | include $(MAPLE_BUILD_CORE)/java2jar.mk 21 | 22 | .PHONY: clean 23 | clean: 24 | @rm -rf *.jar 25 | @rm -f *.class 26 | @rm -f *.mpl 27 | @rm -f *.mplt 28 | @rm -f *.s 29 | @rm -f *.groots.txt 30 | @rm -f *.primordials.txt 31 | @rm -rf comb.log 32 | @rm -rf *.muid 33 | -------------------------------------------------------------------------------- /build/core/maple_variables.mk: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | # 4 | # OpenArkCompiler is licensed under the Mulan PSL v1. 5 | # You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | # You may obtain a copy of Mulan PSL v1 at: 7 | # 8 | # http://license.coscl.org.cn/MulanPSL 9 | # 10 | # THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | # FIT FOR A PARTICULAR PURPOSE. 13 | # See the Mulan PSL v1 for more details. 14 | # 15 | OPT := O0 16 | TARGETS := $(APP) 17 | LIB_CORE_PATH := $(MAPLE_ROOT)/libjava-core 18 | LIB_CORE_JAR := $(LIB_CORE_PATH)/java-core.jar 19 | LIB_CORE_MPLT := $(LIB_CORE_PATH)/java-core.mplt 20 | APP_CLASS := $(foreach APP, $(TARGETS), $(APP).class) 21 | APP_JAR := $(foreach APP, $(TARGETS), $(APP).jar) 22 | APP_MPL := $(foreach APP, $(TARGETS), $(APP).mpl) 23 | APP_MPLT:=$(foreach APP, $(TARGETS), $(APP).mplt) 24 | APP_VTABLEIMPL_MPL := $(foreach APP, $(TARGETS), $(APP).VtableImpl.mpl) 25 | APP_S := $(foreach APP, $(TARGETS), $(APP).VtableImpl.s) 26 | 27 | JAVA2JAR := $(MAPLE_ROOT)/output/bin/java2jar 28 | JBC2MPL_BIN := $(MAPLE_ROOT)/output/bin/jbc2mpl 29 | MAPLE_BIN := $(MAPLE_ROOT)/output/bin/maple 30 | MPLCG_BIN := $(MAPLE_ROOT)/output/bin/mplcg 31 | -------------------------------------------------------------------------------- /build/core/mplcomb.mk: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | # 4 | # OpenArkCompiler is licensed under the Mulan PSL v1. 5 | # You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | # You may obtain a copy of Mulan PSL v1 at: 7 | # 8 | # http://license.coscl.org.cn/MulanPSL 9 | # 10 | # THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | # FIT FOR A PARTICULAR PURPOSE. 13 | # See the Mulan PSL v1 for more details. 14 | # 15 | $(APP_S): %.VtableImpl.s : %.jar $(MAPLE_BIN) $(JBC2MPL_BIN) $(LIB_CORE_MPLT) 16 | $(MAPLE_BIN) -$(OPT) --mplt $(LIB_CORE_MPLT) $< 17 | -------------------------------------------------------------------------------- /build/envsetup.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | # 3 | # Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 4 | # 5 | # OpenArkCompiler is licensed under the Mulan PSL v1. 6 | # You can use this software according to the terms and conditions of the Mulan PSL v1. 7 | # You may obtain a copy of Mulan PSL v1 at: 8 | # 9 | # http://license.coscl.org.cn/MulanPSL 10 | # 11 | # THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 12 | # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 13 | # FIT FOR A PARTICULAR PURPOSE. 14 | # See the Mulan PSL v1 for more details. 15 | # 16 | 17 | curdir=$(pwd) 18 | unset MAPLE_ROOT 19 | export MAPLE_ROOT=${curdir} 20 | unset MAPLE_BUILD_CORE 21 | export MAPLE_BUILD_CORE=${MAPLE_ROOT}/build/core 22 | export PATH=$PATH:${MAPLE_ROOT}/output/bin 23 | unset IS_AST2MPL_EXISTS 24 | if [ -d ${MAPLE_ROOT}/src/ast2mpl ]; then 25 | export IS_AST2MPL_EXISTS=1 26 | else 27 | export IS_AST2MPL_EXISTS=0 28 | fi 29 | export GCOV_PREFIX=${MAPLE_ROOT}/report/gcda 30 | export GCOV_PREFIX_STRIP=7 31 | -------------------------------------------------------------------------------- /build/logs/.gitignore: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/c2s/OpenArkCompiler/1755550ea22eb185cbef8cc5864fa273caebf95a/build/logs/.gitignore -------------------------------------------------------------------------------- /doc/cn/media/Topology.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/c2s/OpenArkCompiler/1755550ea22eb185cbef8cc5864fa273caebf95a/doc/cn/media/Topology.png -------------------------------------------------------------------------------- /doc/cn/media/addphase.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/c2s/OpenArkCompiler/1755550ea22eb185cbef8cc5864fa273caebf95a/doc/cn/media/addphase.png -------------------------------------------------------------------------------- /doc/cn/media/interface1.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/c2s/OpenArkCompiler/1755550ea22eb185cbef8cc5864fa273caebf95a/doc/cn/media/interface1.jpg -------------------------------------------------------------------------------- /doc/cn/media/javavmt.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/c2s/OpenArkCompiler/1755550ea22eb185cbef8cc5864fa273caebf95a/doc/cn/media/javavmt.png -------------------------------------------------------------------------------- /doc/en/media/Topology.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/c2s/OpenArkCompiler/1755550ea22eb185cbef8cc5864fa273caebf95a/doc/en/media/Topology.png -------------------------------------------------------------------------------- /doc/en/media/addphase.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/c2s/OpenArkCompiler/1755550ea22eb185cbef8cc5864fa273caebf95a/doc/en/media/addphase.png -------------------------------------------------------------------------------- /doc/en/media/interface1.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/c2s/OpenArkCompiler/1755550ea22eb185cbef8cc5864fa273caebf95a/doc/en/media/interface1.jpg -------------------------------------------------------------------------------- /doc/en/media/javavmt.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/c2s/OpenArkCompiler/1755550ea22eb185cbef8cc5864fa273caebf95a/doc/en/media/javavmt.png -------------------------------------------------------------------------------- /license/LICENSE: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/c2s/OpenArkCompiler/1755550ea22eb185cbef8cc5864fa273caebf95a/license/LICENSE -------------------------------------------------------------------------------- /samples/exceptiontest/Arith.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | public class Arith { 16 | private static native void raise_sigfpe(); 17 | 18 | public static int TestMain( int c ) { 19 | int r = 0; 20 | try { 21 | r += 1; 22 | if( c > 0 ) 23 | raise_sigfpe(); 24 | else if ( c == 0 ) { 25 | r += 103; 26 | throw new ArithmeticException(); 27 | } 28 | r += 3; 29 | } catch( ArithmeticException e ) { 30 | r += 100; 31 | } 32 | return r; 33 | } 34 | 35 | public static void main(String[] args) { 36 | System.out.println(TestMain(-5)); 37 | System.out.println(TestMain(0)); 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /samples/exceptiontest/Makefile: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | # 4 | # OpenArkCompiler is licensed under the Mulan PSL v1. 5 | # You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | # You may obtain a copy of Mulan PSL v1 at: 7 | # 8 | # http://license.coscl.org.cn/MulanPSL 9 | # 10 | # THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | # FIT FOR A PARTICULAR PURPOSE. 13 | # See the Mulan PSL v1 for more details. 14 | # 15 | APP = Arith 16 | include $(MAPLE_BUILD_CORE)/maple_test.mk 17 | -------------------------------------------------------------------------------- /samples/helloworld/HelloWorld.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | public class HelloWorld { 16 | public static void main(String[] args) { 17 | System.out.println("Hello World!"); 18 | } 19 | } 20 | 21 | -------------------------------------------------------------------------------- /samples/helloworld/Makefile: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | # 4 | # OpenArkCompiler is licensed under the Mulan PSL v1. 5 | # You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | # You may obtain a copy of Mulan PSL v1 at: 7 | # 8 | # http://license.coscl.org.cn/MulanPSL 9 | # 10 | # THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | # FIT FOR A PARTICULAR PURPOSE. 13 | # See the Mulan PSL v1 for more details. 14 | # 15 | APP = HelloWorld 16 | include $(MAPLE_BUILD_CORE)/maple_test.mk 17 | -------------------------------------------------------------------------------- /samples/iteratorandtemplate/IteratorAndTemplateTest.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | import java.util.*; 16 | public class IteratorAndTemplateTest { 17 | public static void main(String args[]) { 18 | testIterator(); 19 | testTemplate(); 20 | } 21 | 22 | public static void testIterator(){ 23 | AbstractCollection l = new ArrayList(); 24 | l.add(new String("Hello")); 25 | l.add(new String(" World")); 26 | System.out.println(l.size()); 27 | System.out.println(l.toString()); 28 | } 29 | 30 | public static void testTemplate(){ 31 | List wholeChain = new ArrayList(); 32 | wholeChain.add(1); 33 | wholeChain.add(2); 34 | for (Integer i : wholeChain) { 35 | System.out.println(i); 36 | } 37 | } 38 | } 39 | 40 | -------------------------------------------------------------------------------- /samples/iteratorandtemplate/Makefile: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | # 4 | # OpenArkCompiler is licensed under the Mulan PSL v1. 5 | # You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | # You may obtain a copy of Mulan PSL v1 at: 7 | # 8 | # http://license.coscl.org.cn/MulanPSL 9 | # 10 | # THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | # FIT FOR A PARTICULAR PURPOSE. 13 | # See the Mulan PSL v1 for more details. 14 | # 15 | APP = IteratorAndTemplateTest 16 | include $(MAPLE_BUILD_CORE)/maple_test.mk 17 | -------------------------------------------------------------------------------- /samples/polymorphismtest/InterfaceTest.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | interface Inter { 16 | public default void foo() { 17 | System.out.println("Inter.foo()"); 18 | } 19 | } 20 | 21 | class Base implements Inter { 22 | public void foo() { 23 | System.out.println("Base.foo()"); 24 | } 25 | } 26 | 27 | class Derived extends Base { 28 | public void foo() { 29 | System.out.println("Derived.foo()"); 30 | } 31 | } 32 | 33 | public class InterfaceTest { 34 | public static void main(String[] args) { 35 | Derived o1 = new Derived(); 36 | o1.foo(); 37 | Base o2 = new Derived(); 38 | o2.foo(); 39 | Inter o3 = new Derived(); 40 | o3.foo(); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /samples/polymorphismtest/Makefile: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | # 4 | # OpenArkCompiler is licensed under the Mulan PSL v1. 5 | # You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | # You may obtain a copy of Mulan PSL v1 at: 7 | # 8 | # http://license.coscl.org.cn/MulanPSL 9 | # 10 | # THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | # FIT FOR A PARTICULAR PURPOSE. 13 | # See the Mulan PSL v1 for more details. 14 | # 15 | APP = InterfaceTest 16 | include $(MAPLE_BUILD_CORE)/maple_test.mk 17 | -------------------------------------------------------------------------------- /samples/rccycletest/Makefile: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | # 4 | # OpenArkCompiler is licensed under the Mulan PSL v1. 5 | # You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | # You may obtain a copy of Mulan PSL v1 at: 7 | # 8 | # http://license.coscl.org.cn/MulanPSL 9 | # 10 | # THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | # FIT FOR A PARTICULAR PURPOSE. 13 | # See the Mulan PSL v1 for more details. 14 | # 15 | APP = RCCycleTest 16 | include $(MAPLE_BUILD_CORE)/maple_test.mk 17 | -------------------------------------------------------------------------------- /samples/rccycletest/RCCycleTest.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | class Test_A { 16 | Test_B bb; 17 | void genCycle() { 18 | Test_B b = new Test_B(); 19 | bb = b; 20 | b.aa = this; 21 | } 22 | } 23 | 24 | class Test_B { 25 | Test_A aa; 26 | } 27 | 28 | public class RCCycleTest { 29 | public static void main (String []args) { 30 | Test_A a = new Test_A(); 31 | a.genCycle(); 32 | if (a.bb == null) { 33 | System.out.println("class B is collected"); 34 | } else { 35 | System.out.println("class B is not collected"); 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /samples/threadtest/Makefile: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | # 4 | # OpenArkCompiler is licensed under the Mulan PSL v1. 5 | # You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | # You may obtain a copy of Mulan PSL v1 at: 7 | # 8 | # http://license.coscl.org.cn/MulanPSL 9 | # 10 | # THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | # FIT FOR A PARTICULAR PURPOSE. 13 | # See the Mulan PSL v1 for more details. 14 | # 15 | APP = ThreadTest 16 | include $(MAPLE_BUILD_CORE)/maple_test.mk 17 | -------------------------------------------------------------------------------- /samples/threadtest/ThreadTest.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | public class ThreadTest { 16 | static volatile long flag = 0L; 17 | static int number = 0; 18 | static class FirstThread extends Thread { 19 | public void run() { 20 | while(flag != Long.MAX_VALUE) { 21 | } 22 | System.out.println(number); 23 | } 24 | } 25 | static class SecondThread extends Thread { 26 | public void run() { 27 | number = 42; 28 | flag = Long.MAX_VALUE; 29 | } 30 | } 31 | 32 | public static void main(String args[]) { 33 | FirstThread t1 = new FirstThread(); 34 | SecondThread t2 = new SecondThread(); 35 | t1.start(); 36 | t2.start(); 37 | try { 38 | t1.join(); 39 | t2.join(); 40 | } catch (InterruptedException e) { 41 | System.out.println("INTERRUPTED_MESSAGE"); 42 | } 43 | System.out.println("OK"); 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /src/BUILD.gn: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | # 4 | # OpenArkCompiler is licensed under the Mulan PSL v1. 5 | # You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | # You may obtain a copy of Mulan PSL v1 at: 7 | # 8 | # http://license.coscl.org.cn/MulanPSL 9 | # 10 | # THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | # FIT FOR A PARTICULAR PURPOSE. 13 | # See the Mulan PSL v1 for more details. 14 | # 15 | config("mapleallcompilecfg") { 16 | cflags_cc = [] 17 | cflags_cc += [ 18 | "-std=c++14", 19 | "-Werror", 20 | "-DTARGAARCH64", 21 | ] 22 | 23 | if (GN_BUILD_TYPE == "DEBUG") { 24 | cflags_c += [ "-DDEBUG" ] 25 | cflags_cc += [ "-DDEBUG" ] 26 | } 27 | 28 | if (HOST_ARCH == 64) { 29 | ldflags = [] 30 | ldflags += [ 31 | "-fPIC", 32 | "-std=c++14", 33 | "-rdynamic", 34 | "-lpthread", 35 | "-Wl,-z,relro", 36 | "-Wl,-z,now", 37 | "-Wl,-z,noexecstack", 38 | "-pie", 39 | ] 40 | } 41 | } 42 | 43 | group("maple") { 44 | deps = [ 45 | "${MAPLEALL_ROOT}/maple_driver:maple", 46 | ] 47 | } 48 | 49 | group("irbuild") { 50 | deps = [ 51 | "${MAPLEALL_ROOT}/maple_ir:irbuild", 52 | ] 53 | } 54 | 55 | group("maplegen") { 56 | deps = [ 57 | "${MAPLEALL_ROOT}/maple_be:maplegen", 58 | ] 59 | } 60 | -------------------------------------------------------------------------------- /src/bin/java2jar: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | # 3 | # Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 4 | # 5 | # OpenArkCompiler is licensed under the Mulan PSL v1. 6 | # You can use this software according to the terms and conditions of the Mulan PSL v1. 7 | # You may obtain a copy of Mulan PSL v1 at: 8 | # 9 | # http://license.coscl.org.cn/MulanPSL 10 | # 11 | # THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 12 | # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 13 | # FIT FOR A PARTICULAR PURPOSE. 14 | # See the Mulan PSL v1 for more details. 15 | # 16 | OUTPUT=$1 17 | CORE_ALL_JAR=$2 18 | shift 2 19 | javac -g -d . -bootclasspath ${CORE_ALL_JAR} $@ 20 | jar -cvf ${OUTPUT} *.class 21 | -------------------------------------------------------------------------------- /src/bin/jbc2mpl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/c2s/OpenArkCompiler/1755550ea22eb185cbef8cc5864fa273caebf95a/src/bin/jbc2mpl -------------------------------------------------------------------------------- /src/bin/maple: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/c2s/OpenArkCompiler/1755550ea22eb185cbef8cc5864fa273caebf95a/src/bin/maple -------------------------------------------------------------------------------- /src/deplibs/libmempool.a: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/c2s/OpenArkCompiler/1755550ea22eb185cbef8cc5864fa273caebf95a/src/deplibs/libmempool.a -------------------------------------------------------------------------------- /src/deplibs/libmplphase.a: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/c2s/OpenArkCompiler/1755550ea22eb185cbef8cc5864fa273caebf95a/src/deplibs/libmplphase.a -------------------------------------------------------------------------------- /src/deplibs/libmplutil.a: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/c2s/OpenArkCompiler/1755550ea22eb185cbef8cc5864fa273caebf95a/src/deplibs/libmplutil.a -------------------------------------------------------------------------------- /src/huawei_secure_c/src/secureinput_a.c: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #define SECUREC_FORMAT_OUTPUT_INPUT 1 16 | #ifdef SECUREC_FOR_WCHAR 17 | #undef SECUREC_FOR_WCHAR 18 | #endif 19 | 20 | #include "secinput.h" 21 | 22 | #include "input.inl" 23 | 24 | SECUREC_INLINE int SecIsDigit(SecInt ch) 25 | { 26 | /* SecInt to unsigned char clear 571 */ 27 | return isdigit((unsigned char)(ch) & 0x00ff); 28 | } 29 | SECUREC_INLINE int SecIsXdigit(SecInt ch) 30 | { 31 | return isxdigit((unsigned char)(ch) & 0x00ff); 32 | } 33 | SECUREC_INLINE int SecIsSpace(SecInt ch) 34 | { 35 | return isspace((unsigned char)(ch) & 0x00ff); 36 | } 37 | 38 | -------------------------------------------------------------------------------- /src/maple_be/include/ad/target/mplad_arch_define.def: -------------------------------------------------------------------------------- 1 | /* cortex_a55 Architecture definition : */ 2 | SetMaxParallelism(2); 3 | -------------------------------------------------------------------------------- /src/maple_be/include/ad/target/mplad_latency_type.def: -------------------------------------------------------------------------------- 1 | /* cortex_a55 latency type definition definition : */ 2 | kLtUndef, 3 | kLtShift, 4 | kLtShiftReg, 5 | kLtAlu, 6 | kLtAluShift, 7 | kLtAluShiftReg, 8 | kLtAluExtr, 9 | kLtMul, 10 | kLtDiv, 11 | kLtLoad1, 12 | kLtStore1, 13 | kLtLoad2, 14 | kLtStore2, 15 | kLtLoad3plus, 16 | kLtStore3plus, 17 | kLtBranch, 18 | kLtFpalu, 19 | kLtFconst, 20 | kLtFpmul, 21 | kLtFpmac, 22 | kLtR2f, 23 | kLtF2r, 24 | kLtR2fCvt, 25 | kLtF2rCvt, 26 | kLtFFlags, 27 | kLtFLoad64, 28 | kLtFLoadMany, 29 | kLtFStore64, 30 | kLtFStoreMany, 31 | kLtAdvsimdAlu, 32 | kLtAdvsimdAluQ, 33 | kLtAdvsimdMul, 34 | kLtAdvsimdMulQ, 35 | kLtAdvsimdDivS, 36 | kLtAdvsimdDivD, 37 | kLtAdvsimdDivSQ, 38 | kLtAdvsimdDivdQ, 39 | kLtCryptoAese, 40 | kLtCryptoAesmc, 41 | kLtClinit, 42 | kLtAdrpLdr, 43 | kLtClinitTail, 44 | -------------------------------------------------------------------------------- /src/maple_be/include/ad/target/mplad_unit_id.def: -------------------------------------------------------------------------------- 1 | /* cortex_a55 function unit ID definition : */ 2 | kUnitIdSlot0, 3 | kUnitIdSlot1, 4 | kUnitIdAgen, 5 | kUnitIdHazard, 6 | kUnitIdCrypto, 7 | kUnitIdMul, 8 | kUnitIdDiv, 9 | kUnitIdBranch, 10 | kUnitIdStAgu, 11 | kUnitIdLdAgu, 12 | kUnitIdFpAluLo, 13 | kUnitIdFpAluHi, 14 | kUnitIdFpMulLo, 15 | kUnitIdFpMulHi, 16 | kUnitIdFpDivLo, 17 | kUnitIdFpDivHi, 18 | kUnitIdSlotS, 19 | kUnitIdFpAluS, 20 | kUnitIdFpMulS, 21 | kUnitIdFpDivS, 22 | kUnitIdSlotD, 23 | kUnitIdFpAluD, 24 | kUnitIdFpMulD, 25 | kUnitIdFpDivD, 26 | kUnitIdSlotSHazard, 27 | kUnitIdSlotSMul, 28 | kUnitIdSlotSBranch, 29 | kUnitIdSlotSAgen, 30 | kUnitIdSlotDAgen, 31 | kUnitIdSlot0LdAgu, 32 | kUnitIdSlot0StAgu, 33 | nothing, 34 | -------------------------------------------------------------------------------- /src/maple_be/include/ad/target/mplad_unit_kind.def: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | /* cortex_a55 function unit ID definition: */ 16 | kUnitKindSlot0 = 1, 17 | kUnitKindAgen = 2, 18 | kUnitKindHazard = 4, 19 | kUnitKindCrypto = 8, 20 | kUnitKindMul = 16, 21 | kUnitKindDiv = 32, 22 | kUnitKindBranch = 64, 23 | kUnitKindStAgu = 128, 24 | kUnitKindLdAgu = 256, 25 | kUnitKindFpAlu = 512, 26 | kUnitKindFpMul = 1024, 27 | kUnitKindFpDiv = 2048, 28 | 29 | -------------------------------------------------------------------------------- /src/maple_be/include/ad/target/mplad_unit_name.def: -------------------------------------------------------------------------------- 1 | /* cortex_a55 function unit name definition : */ 2 | "Slot0", 3 | "Slot1", 4 | "Agen", 5 | "Hazard", 6 | "Crypto", 7 | "Mul", 8 | "Div", 9 | "Branch", 10 | "StAgu", 11 | "LdAgu", 12 | "FpAluLo", 13 | "FpAluHi", 14 | "FpMulLo", 15 | "FpMulHi", 16 | "FpDivLo", 17 | "FpDivHi", 18 | "SlotS", 19 | "FpAluS", 20 | "FpMulS", 21 | "FpDivS", 22 | "SlotD", 23 | "FpAluD", 24 | "FpMulD", 25 | "FpDivD", 26 | "SlotSHazard", 27 | "SlotSMul", 28 | "SlotSBranch", 29 | "SlotSAgen", 30 | "SlotDAgen", 31 | "Slot0LdAgu", 32 | "Slot0StAgu", 33 | -------------------------------------------------------------------------------- /src/maple_be/include/be/array_base_name.def: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | "ALjava_2Flang_2FObject_3B", 16 | "ALjava_2Flang_2FClass_3B", 17 | "ALjava_2Flang_2FString_3B" 18 | -------------------------------------------------------------------------------- /src/maple_be/include/be/array_klass_name.def: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | "ALjava_2Flang_2FObject_3B", 16 | "ALjava_2Flang_2FClass_3B", 17 | "ALjava_2Flang_2FString_3B", 18 | "ALjava_2Futil_2FFormatter_24Flags_3B", 19 | "ALjava_2Futil_2FHashMap_24Node_3B", 20 | "ALjava_2Futil_2FFormatter_24FormatString_3B", 21 | "ALjava_2Flang_2FCharSequence_3B", 22 | "ALjava_2Flang_2FThreadLocal_24ThreadLocalMap_24Entry_3B", 23 | "ALjava_2Futil_2FHashtable_24HashtableEntry_3B", 24 | "ALlibcore_2Freflect_2FAnnotationMember_3B", 25 | "ALsun_2Fsecurity_2Futil_2FDerValue_3B", 26 | "ALsun_2Fsecurity_2Fx509_2FAVA_3B" -------------------------------------------------------------------------------- /src/maple_be/include/be/rt.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MAPLEBE_INCLUDE_BE_RT_H 16 | #define MAPLEBE_INCLUDE_BE_RT_H 17 | 18 | #include 19 | #include 20 | 21 | namespace maplebe { 22 | /* 23 | * This class contains constants about the ABI of the runtime, such as symbols 24 | * for GC-related metadata in generated binary files. 25 | */ 26 | class RTSupport { 27 | private: 28 | static const std::string kObjectMapSectionName; 29 | static const std::string kGctibLabelArrayOfObject; 30 | static const std::string kGctibLabelJavaObject; 31 | }; 32 | } /* namespace maplebe */ 33 | 34 | #endif /* MAPLEBE_INCLUDE_BE_RT_H */ -------------------------------------------------------------------------------- /src/maple_be/include/cg/aarch64/aarch64_cc.def: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | CONDCODE(EQ) /* equal */ 16 | CONDCODE(NE) /* not equal */ 17 | CONDCODE(CS) /* carry set (== HS) */ 18 | CONDCODE(HS) /* unsigned higher or same (== CS) */ 19 | CONDCODE(CC) /* carry clear (== LO) */ 20 | CONDCODE(LO) /* Unsigned lower (== CC) */ 21 | CONDCODE(MI) /* Minus or negative result */ 22 | CONDCODE(PL) /* positive or zero result */ 23 | CONDCODE(VS) /* overflow */ 24 | CONDCODE(VC) /* no overflow */ 25 | CONDCODE(HI) /* unsigned higher */ 26 | CONDCODE(LS) /* unsigned lower or same */ 27 | CONDCODE(GE) /* signed greater than or equal */ 28 | CONDCODE(LT) /* signed less than */ 29 | CONDCODE(GT) /* signed greater than */ 30 | CONDCODE(LE) /* signed less than or equal */ 31 | CONDCODE(AL) /* always, this is the default. usually omitted. */ 32 | -------------------------------------------------------------------------------- /src/maple_be/include/cg/aarch64/aarch64_fixshortbranch.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_FIXSHORTBRANCH_H 16 | #define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_FIXSHORTBRANCH_H 17 | 18 | #include 19 | #include "aarch64_cg.h" 20 | #include "optimize_common.h" 21 | #include "mir_builder.h" 22 | 23 | namespace maplebe { 24 | class AArch64FixShortBranch { 25 | public: 26 | explicit AArch64FixShortBranch(CGFunc *cf) : cgFunc(cf) { 27 | cg = cgFunc->GetCG(); 28 | } 29 | ~AArch64FixShortBranch() = default; 30 | void FixShortBranches(); 31 | 32 | private: 33 | CGFunc *cgFunc; 34 | CG *cg; 35 | bool DistanceCheck(const BB &bb, LabelIdx targLabIdx, uint32 targId); 36 | void SetInsnId(); 37 | }; /* class AArch64ShortBranch */ 38 | 39 | CGFUNCPHASE(CgFixShortBranch, "fixshortbranch") 40 | } /* namespace maplebe */ 41 | #endif /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_FIXSHORTBRANCH_H */ 42 | -------------------------------------------------------------------------------- /src/maple_be/include/cg/aarch64/aarch64_immediate.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_IMMEDIATE_H 16 | #define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_IMMEDIATE_H 17 | 18 | #include "types_def.h" /* maple_ir/include/typedef.h */ 19 | #include 20 | 21 | namespace maplebe { 22 | bool IsBitmaskImmediate(maple::uint64 val, maple::uint32 bitLen); 23 | bool IsMoveWidableImmediate(maple::uint64 val, maple::uint32 bitLen); 24 | bool BetterUseMOVZ(maple::uint64 val); 25 | } /* namespace maplebe */ 26 | 27 | #endif /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_IMMEDIATE_H */ -------------------------------------------------------------------------------- /src/maple_be/include/cg/aarch64/aarch64_live.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_LIVE_H 16 | #define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_LIVE_H 17 | 18 | #include "live.h" 19 | 20 | namespace maplebe { 21 | class AArch64LiveAnalysis : public LiveAnalysis { 22 | public: 23 | AArch64LiveAnalysis(CGFunc &func, MemPool &memPool) : LiveAnalysis(func, memPool) {} 24 | ~AArch64LiveAnalysis() override = default; 25 | void GetBBDefUse(BB &bb) override; 26 | bool CleanupBBIgnoreReg(uint32 reg) override; 27 | void InitEhDefine(BB &bb) override; 28 | private: 29 | void CollectLiveInfo(BB &bb, const Operand &opnd, bool isDef, bool isUse) const; 30 | void GenerateReturnBBDefUse(BB &bb) const; 31 | void ProcessCallInsnParam(BB &bb) const; 32 | void ProcessListOpnd(BB &bb, Operand &opnd) const; 33 | void ProcessMemOpnd(BB &bb, Operand &opnd) const; 34 | void ProcessCondOpnd(BB &bb) const; 35 | }; 36 | } /* namespace maplebe */ 37 | 38 | #endif /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_LIVE_H */ -------------------------------------------------------------------------------- /src/maple_be/include/cg/aarch64/aarch64_offset_adjust.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_OFFSET_ADJUST_H 16 | #define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_OFFSET_ADJUST_H 17 | 18 | #include "offset_adjust.h" 19 | #include "aarch64_cgfunc.h" 20 | 21 | namespace maplebe { 22 | using namespace maple; 23 | 24 | class AArch64FPLROffsetAdjustment : public FPLROffsetAdjustment { 25 | public: 26 | explicit AArch64FPLROffsetAdjustment(CGFunc &func) : FPLROffsetAdjustment(func) {} 27 | 28 | ~AArch64FPLROffsetAdjustment() override = default; 29 | 30 | void Run() override; 31 | 32 | private: 33 | void AdjustmentOffsetForOpnd(Insn &insn, AArch64CGFunc &aarchCGFunc); 34 | void AdjustmentOffsetForFPLR(); 35 | }; 36 | } /* namespace maplebe */ 37 | 38 | #endif /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_OFFSET_ADJUST_H */ -------------------------------------------------------------------------------- /src/maple_be/include/cg/aarch64/aarch64_yieldpoint.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_YIELDPOINT_H 16 | #define MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_YIELDPOINT_H 17 | 18 | #include "yieldpoint.h" 19 | 20 | namespace maplebe { 21 | using namespace maple; 22 | 23 | class AArch64YieldPointInsertion : public YieldPointInsertion { 24 | public: 25 | explicit AArch64YieldPointInsertion(CGFunc &func) : YieldPointInsertion(func) {} 26 | 27 | ~AArch64YieldPointInsertion() override = default; 28 | 29 | void Run() override; 30 | 31 | private: 32 | void InsertYieldPoint(); 33 | }; 34 | } /* namespace maplebe */ 35 | 36 | #endif /* MAPLEBE_INCLUDE_CG_AARCH64_AARCH64_YIELDPOINT_H */ -------------------------------------------------------------------------------- /src/maple_be/include/cg/aarch64/mpl_atomic.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MAPLEBE_INCLUDE_CG_AARCH64_MPL_ATOMIC_H 16 | #define MAPLEBE_INCLUDE_CG_AARCH64_MPL_ATOMIC_H 17 | 18 | #include 19 | #include 20 | #include "types_def.h" 21 | 22 | namespace maple { 23 | enum class MemOrd : uint32 { 24 | kNotAtomic = 0, 25 | #define ATTR(STR) STR, 26 | #include "memory_order_attrs.def" 27 | #undef ATTR 28 | }; 29 | 30 | MemOrd MemOrdFromU32(uint32 val); 31 | 32 | bool MemOrdIsAcquire(MemOrd ord); 33 | 34 | bool MemOrdIsRelease(MemOrd ord); 35 | } /* namespace maple */ 36 | 37 | #endif /* MAPLEBE_INCLUDE_CG_AARCH64_MPL_ATOMIC_H */ -------------------------------------------------------------------------------- /src/maple_be/include/cg/args.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MAPLEBE_INCLUDE_CG_ARGS_H 16 | #define MAPLEBE_INCLUDE_CG_ARGS_H 17 | 18 | #include "cgfunc.h" 19 | #include "cg_phase.h" 20 | 21 | namespace maplebe { 22 | class MoveRegArgs { 23 | public: 24 | explicit MoveRegArgs(CGFunc &func) : cgFunc(&func) {} 25 | 26 | virtual ~MoveRegArgs() = default; 27 | 28 | virtual void Run() {} 29 | 30 | std::string PhaseName() const { 31 | return "moveargs"; 32 | } 33 | 34 | const CGFunc *GetCGFunc() const { 35 | return cgFunc; 36 | } 37 | 38 | protected: 39 | CGFunc *cgFunc; 40 | }; 41 | 42 | CGFUNCPHASE(CgDoMoveRegArgs, "moveargs") 43 | } /* namespace maplebe */ 44 | 45 | #endif /* MAPLEBE_INCLUDE_CG_ARGS_H */ -------------------------------------------------------------------------------- /src/maple_be/include/cg/global.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MAPLEBE_INCLUDE_CG_GLOBAL_H 16 | #define MAPLEBE_INCLUDE_CG_GLOBAL_H 17 | 18 | #include "cg_phase.h" 19 | 20 | namespace maplebe { 21 | class GlobalOpt { 22 | public: 23 | explicit GlobalOpt(CGFunc &func) : cgFunc(func) {} 24 | virtual ~GlobalOpt() = default; 25 | virtual void Run() {} 26 | std::string PhaseName() const { 27 | return "globalopt"; 28 | } 29 | 30 | protected: 31 | /* if the number of bbs is more than 500 or the number of insns is more than 9000, don't optimize. */ 32 | static constexpr uint32 kMaxBBNum = 500; 33 | static constexpr uint32 kMaxInsnNum = 9000; 34 | CGFunc &cgFunc; 35 | }; 36 | 37 | CGFUNCPHASE_CANSKIP(CgDoGlobalOpt, "globalopt") 38 | } /* namespace maplebe */ 39 | 40 | #endif /* MAPLEBE_INCLUDE_CG_GLOBAL_H */ -------------------------------------------------------------------------------- /src/maple_be/include/cg/label_creation.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MAPLEBE_INCLUDE_CG_LABEL_CREATION_H 16 | #define MAPLEBE_INCLUDE_CG_LABEL_CREATION_H 17 | 18 | #include "cgfunc.h" 19 | #include "cg_phase.h" 20 | #include "mir_builder.h" 21 | 22 | namespace maplebe { 23 | class LabelCreation { 24 | public: 25 | explicit LabelCreation(CGFunc &func) : cgFunc(&func) {} 26 | 27 | ~LabelCreation() = default; 28 | 29 | void Run(); 30 | 31 | std::string PhaseName() const { 32 | return "createlabel"; 33 | } 34 | 35 | private: 36 | CGFunc *cgFunc; 37 | void CreateStartEndLabel(); 38 | }; 39 | 40 | CGFUNCPHASE(CgDoCreateLabel, "createstartendlabel") 41 | } /* namespace maplebe */ 42 | 43 | #endif /* MAPLEBE_INCLUDE_CG_LABEL_CREATION_H */ -------------------------------------------------------------------------------- /src/maple_be/include/cg/offset_adjust.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MAPLEBE_INCLUDE_CG_OFFSET_ADJUST_H 16 | #define MAPLEBE_INCLUDE_CG_OFFSET_ADJUST_H 17 | 18 | #include "cgfunc.h" 19 | #include "cg_phase.h" 20 | 21 | namespace maplebe { 22 | class FPLROffsetAdjustment { 23 | public: 24 | explicit FPLROffsetAdjustment(CGFunc &func) : cgFunc(&func) {} 25 | 26 | virtual ~FPLROffsetAdjustment() = default; 27 | 28 | virtual void Run() {} 29 | 30 | std::string PhaseName() const { 31 | return "offsetadjustforfplr"; 32 | } 33 | 34 | protected: 35 | CGFunc *cgFunc; 36 | }; 37 | 38 | CGFUNCPHASE(CgDoFPLROffsetAdjustment, "offsetadjustforfplr") 39 | } /* namespace maplebe */ 40 | 41 | #endif /* MAPLEBE_INCLUDE_CG_OFFSET_ADJUST_H */ -------------------------------------------------------------------------------- /src/maple_be/include/cg/strldr.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MAPLEBE_INCLUDE_CG_STRLDR_H 16 | #define MAPLEBE_INCLUDE_CG_STRLDR_H 17 | #include "cg_phase.h" 18 | 19 | namespace maplebe { 20 | class StoreLoadOpt { 21 | public: 22 | StoreLoadOpt(CGFunc &func, MemPool &memPool) : cgFunc(func), memPool(memPool) {} 23 | virtual ~StoreLoadOpt() = default; 24 | virtual void Run() = 0; 25 | std::string PhaseName() const { 26 | return "storeloadopt"; 27 | } 28 | 29 | protected: 30 | CGFunc &cgFunc; 31 | MemPool &memPool; 32 | /* if the number of bbs is more than 500 or the number of insns is more than 9000, don't optimize. */ 33 | static constexpr uint32 kMaxBBNum = 500; 34 | static constexpr uint32 kMaxInsnNum = 9000; 35 | }; 36 | 37 | CGFUNCPHASE_CANSKIP(CgDoStoreLoadOpt, "storeloadopt") 38 | } /* namespace maplebe */ 39 | 40 | #endif /* MAPLEBE_INCLUDE_CG_STRLDR_H */ -------------------------------------------------------------------------------- /src/maple_be/include/cg/yieldpoint.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MAPLEBE_INCLUDE_CG_YIELDPOINT_H 16 | #define MAPLEBE_INCLUDE_CG_YIELDPOINT_H 17 | 18 | #include "cgfunc.h" 19 | #include "cg_phase.h" 20 | 21 | namespace maplebe { 22 | class YieldPointInsertion { 23 | public: 24 | explicit YieldPointInsertion(CGFunc &func) : cgFunc(&func) {} 25 | 26 | virtual ~YieldPointInsertion() = default; 27 | 28 | virtual void Run() {} 29 | 30 | std::string PhaseName() const { 31 | return "yieldpoint"; 32 | } 33 | 34 | protected: 35 | CGFunc *cgFunc; 36 | }; 37 | 38 | CGFUNCPHASE(CgYieldPointInsertion, "yieldpoint") 39 | } /* namespace maplebe */ 40 | 41 | #endif /* MAPLEBE_INCLUDE_CG_YIELDPOINT_H */ -------------------------------------------------------------------------------- /src/maple_be/src/be/rt.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #include "rt.h" 16 | 17 | namespace maplebe { 18 | const std::string RTSupport::kObjectMapSectionName = ".maple.objectmap"; 19 | const std::string RTSupport::kGctibLabelArrayOfObject = "MCC_GCTIB___ArrayOfObject"; 20 | const std::string RTSupport::kGctibLabelJavaObject = "MCC_GCTIB__Ljava_2Flang_2FObject_3B"; 21 | } /* namespace maplebe */ 22 | -------------------------------------------------------------------------------- /src/maple_be/src/cg/aarch64/aarch64_isa.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | 16 | #include "aarch64_isa.h" 17 | 18 | namespace maplebe { 19 | /* 20 | * Get the ldp/stp corresponding to ldr/str 21 | * mop : a ldr or str machine operator 22 | */ 23 | MOperator GetMopPair(MOperator mop) { 24 | switch (mop) { 25 | case MOP_xldr: 26 | return MOP_xldp; 27 | case MOP_wldr: 28 | return MOP_wldp; 29 | case MOP_xstr: 30 | return MOP_xstp; 31 | case MOP_wstr: 32 | return MOP_wstp; 33 | case MOP_dldr: 34 | return MOP_dldp; 35 | case MOP_sldr: 36 | return MOP_sldp; 37 | case MOP_dstr: 38 | return MOP_dstp; 39 | case MOP_sstr: 40 | return MOP_sstp; 41 | default: 42 | ASSERT(false, "should not run here"); 43 | return MOP_undef; 44 | } 45 | } 46 | } /* namespace maplebe */ -------------------------------------------------------------------------------- /src/maple_be/src/cg/args.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #include "args.h" 16 | #if TARGAARCH64 17 | #include "aarch64_args.h" 18 | #endif 19 | #if TARGARM32 20 | #include "arm32_args.h" 21 | #endif 22 | #include "cgfunc.h" 23 | 24 | namespace maplebe { 25 | using namespace maple; 26 | AnalysisResult *CgDoMoveRegArgs::Run(CGFunc *cgFunc, CgFuncResultMgr *cgFuncResultMgr) { 27 | (void)cgFuncResultMgr; 28 | MemPool *memPool = NewMemPool(); 29 | MoveRegArgs *movRegArgs = nullptr; 30 | ASSERT(cgFunc != nullptr, "expect a cgfunc in CgDoMoveRegArgs"); 31 | #if TARGAARCH64 32 | movRegArgs = memPool->New(*cgFunc); 33 | #endif 34 | #if TARGARM32 35 | movRegArgs = memPool->New(*cgFunc); 36 | #endif 37 | movRegArgs->Run(); 38 | 39 | return nullptr; 40 | } 41 | } /* namespace maplebe */ 42 | -------------------------------------------------------------------------------- /src/maple_be/src/cg/offset_adjust.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #include "offset_adjust.h" 16 | #if TARGAARCH64 17 | #include "aarch64_offset_adjust.h" 18 | #endif 19 | #if TARGARM32 20 | #include "arm32_offset_adjust.h" 21 | #endif 22 | 23 | #include "cgfunc.h" 24 | 25 | namespace maplebe { 26 | using namespace maple; 27 | AnalysisResult *CgDoFPLROffsetAdjustment::Run(CGFunc *cgFunc, CgFuncResultMgr *cgFuncResultMgr) { 28 | (void)cgFuncResultMgr; 29 | MemPool *memPool = NewMemPool(); 30 | FPLROffsetAdjustment *offsetAdjustment = nullptr; 31 | ASSERT(cgFunc != nullptr, "expect a cgfun in CgDoFPLROffsetAdjustment"); 32 | #if TARGAARCH64 33 | offsetAdjustment = memPool->New(*cgFunc); 34 | #endif 35 | #if TARGARM32 36 | offsetAdjustment = memPool->New(*cgFunc); 37 | #endif 38 | offsetAdjustment->Run(); 39 | return nullptr; 40 | } 41 | } /* namespace maplebe */ 42 | -------------------------------------------------------------------------------- /src/maple_be/src/cg/pressure.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #include "pressure.h" 16 | #include "aarch64_schedule.h" 17 | #include "deps.h" 18 | 19 | namespace maplebe { 20 | /* ------- RegPressure function -------- */ 21 | int32 RegPressure::maxRegClassNum = 0; 22 | 23 | /* print regpressure information */ 24 | void RegPressure::DumpRegPressure() const { 25 | PRINT_STR_VAL("Priority: ", priority); 26 | PRINT_STR_VAL("maxDepth: ", maxDepth); 27 | PRINT_STR_VAL("near: ", near); 28 | PRINT_STR_VAL("callNum: ", callNum); 29 | 30 | LogInfo::MapleLogger() << "\n"; 31 | } 32 | } /* namespace maplebe */ 33 | 34 | -------------------------------------------------------------------------------- /src/maple_be/src/cg/yieldpoint.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #include "yieldpoint.h" 16 | #if TARGAARCH64 17 | #include "aarch64_yieldpoint.h" 18 | #endif 19 | #if TARGARM32 20 | #include "arm32_yieldpoint.h" 21 | #endif 22 | #include "cgfunc.h" 23 | 24 | namespace maplebe { 25 | using namespace maple; 26 | AnalysisResult *CgYieldPointInsertion::Run(CGFunc *cgFunc, CgFuncResultMgr *cgFuncResultMgr) { 27 | (void)cgFuncResultMgr; 28 | ASSERT(cgFunc != nullptr, "expect a cgfunc in CgYieldPointInsertion"); 29 | MemPool *memPool = NewMemPool(); 30 | YieldPointInsertion *yieldPoint = nullptr; 31 | #if TARGAARCH64 32 | yieldPoint = memPool->New(*cgFunc); 33 | #endif 34 | #if TARGARM32 35 | yieldPoint = memPool->New(*cgFunc); 36 | #endif 37 | yieldPoint->Run(); 38 | return nullptr; 39 | } 40 | } /* namespace maplebe */ 41 | -------------------------------------------------------------------------------- /src/maple_driver/defs/default/O0_options_jbc2mpl.def: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | // option name, option value, append maple root path? 16 | -------------------------------------------------------------------------------- /src/maple_driver/defs/default/O0_options_me.def: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | // option name, option value, append maple root path? 16 | { "--quiet", "", false }, 17 | -------------------------------------------------------------------------------- /src/maple_driver/defs/default/O0_options_mpl2mpl.def: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | // option name, option value, append maple root path? 16 | { "--quiet", "", false }, 17 | { "-regnativefunc", "", false }, 18 | { "--maplelinker", "", false }, 19 | { "--emitVtableImpl", "", false }, 20 | -------------------------------------------------------------------------------- /src/maple_driver/defs/default/O0_options_mplcg.def: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | // option name, option value, append maple root path? 16 | { "--quiet", "", false }, 17 | { "--no-pie", "", false }, 18 | { "--fpic", "", false }, 19 | { "--verbose-asm", "", false }, 20 | { "--maplelinker", "", false }, 21 | -------------------------------------------------------------------------------- /src/maple_driver/defs/default/O2_options_me.def: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | // option name, option value, append maple root path? 16 | { "-O2", "", false }, 17 | { "--quiet", "", false }, 18 | -------------------------------------------------------------------------------- /src/maple_driver/defs/default/O2_options_mpl2mpl.def: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | // option name, option value, append maple root path? 16 | { "-O2", "", false }, 17 | { "--quiet", "", false }, 18 | { "--regnativefunc", "", false }, 19 | { "--no-nativeopt", "", false }, 20 | { "--emitVtableImpl", "", false }, 21 | -------------------------------------------------------------------------------- /src/maple_driver/defs/default/O2_options_mplcg.def: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | // option name, option value, append maple root path? 16 | { "-O2", "", false }, 17 | { "--quiet", "", false }, 18 | { "--no-pie", "", false }, 19 | { "--verbose-asm", "", false }, 20 | { "--fpic", "", false }, 21 | 22 | -------------------------------------------------------------------------------- /src/maple_driver/src/maple.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #include "compiler_factory.h" 16 | #include "error_code.h" 17 | #include "mpl_options.h" 18 | #include "mpl_logging.h" 19 | 20 | using namespace maple; 21 | 22 | int main(int argc, char **argv) { 23 | MplOptions mplOptions; 24 | int ret = mplOptions.Parse(argc, argv); 25 | if (ret == kErrorNoError) { 26 | ret = CompilerFactory::GetInstance().Compile(mplOptions); 27 | } 28 | PrintErrorMessage(ret); 29 | return ret; 30 | } 31 | -------------------------------------------------------------------------------- /src/maple_ipa/BUILD.gn: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | # 4 | # OpenArkCompiler is licensed under the Mulan PSL v1. 5 | # You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | # You may obtain a copy of Mulan PSL v1 at: 7 | # 8 | # http://license.coscl.org.cn/MulanPSL 9 | # 10 | # THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | # FIT FOR A PARTICULAR PURPOSE. 13 | # See the Mulan PSL v1 for more details. 14 | # 15 | include_directories = [ 16 | "${MAPLEALL_ROOT}/maple_ir/include", 17 | "${MAPLEALL_ROOT}/mempool/include", 18 | "${MAPLEALL_ROOT}/maple_util/include", 19 | "${MAPLEALL_ROOT}/maple_me/include", 20 | "${MAPLEALL_ROOT}/maple_ipa/include", 21 | "${MAPLEALL_ROOT}/mpl2mpl/include", 22 | "${MAPLEALL_ROOT}/maple_phase/include", 23 | "${MAPLEALL_ROOT}/maple_driver/include", 24 | "${MAPLEALL_ROOT}/huawei_secure_c/include", 25 | ] 26 | 27 | src_libmplipa = [ 28 | "src/interleaved_manager.cpp", 29 | "src/module_phase_manager.cpp", 30 | "src/clone.cpp", 31 | "src/retype.cpp", 32 | "src/call_graph.cpp", 33 | ] 34 | 35 | configs = [ "${MAPLEALL_ROOT}:mapleallcompilecfg" ] 36 | 37 | static_library("libmplipa") { 38 | sources = src_libmplipa 39 | include_dirs = include_directories 40 | output_dir = "${root_out_dir}/lib/${HOST_ARCH}" 41 | } 42 | -------------------------------------------------------------------------------- /src/maple_ipa/include/module_phases.def: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | MODAPHASE(MoPhase_CLONE, DoClone) 16 | MODAPHASE(MoPhase_CHA, DoKlassHierarchy) 17 | MODAPHASE(MoPhase_CLINIT, DoClassInit) 18 | MODAPHASE(MoPhase_CALLGRAPH_ANALYSIS, DoCallGraph) 19 | #if MIR_JAVA 20 | MODTPHASE(MoPhase_GENNATIVESTUBFUNC, DoGenerateNativeStubFunc) 21 | MODAPHASE(MoPhase_VTABLEANALYSIS, DoVtableAnalysis) 22 | MODAPHASE(MoPhase_REFLECTIONANALYSIS, DoReflectionAnalysis) 23 | MODAPHASE(MoPhase_ANNOTATIONANALYSIS, DoAnnotationAnalysis) 24 | MODTPHASE(MoPhase_VTABLEIMPL, DoVtableImpl) 25 | MODTPHASE(MoPhase_JAVAINTRNLOWERING, DoJavaIntrnLowering) 26 | MODTPHASE(MoPhase_JAVAEHLOWER, JavaEHLowererPhase) 27 | MODTPHASE(MoPhase_MUIDREPLACEMENT, DoMUIDReplacement) 28 | MODTPHASE(MoPhase_CHECKCASTGENERATION, DoCheckCastGeneration) 29 | MODTPHASE(MoPhase_CodeReLayout, DoCodeReLayout) 30 | #endif 31 | MODTPHASE(MoPhase_CONSTANTFOLD, DoConstantFold) 32 | -------------------------------------------------------------------------------- /src/maple_ipa/include/retype.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MAPLE_IPA_INCLUDE_RETYPE_H 16 | #define MAPLE_IPA_INCLUDE_RETYPE_H 17 | #include "module_phase.h" 18 | #include "mir_nodes.h" 19 | #include "class_hierarchy.h" 20 | 21 | namespace maple { 22 | class Retype { 23 | public: 24 | Retype(MIRModule *mod, MemPool *memPool) : mirModule(mod), allocator(memPool) {} 25 | 26 | ~Retype() = default; 27 | 28 | void ReplaceRetypeExpr(const BaseNode &opnd); 29 | void RetypeStmt(MIRFunction &func); 30 | void DoRetype(); 31 | 32 | private: 33 | MIRModule *mirModule; 34 | MapleAllocator allocator; 35 | std::map reg2varGenericInfo; 36 | void TransmitGenericInfo(MIRFunction &func, StmtNode &stmt); 37 | }; 38 | } // namespace maple 39 | #endif // MAPLE_IPA_INCLUDE_RETYPE_H 40 | -------------------------------------------------------------------------------- /src/maple_ir/include/binary_op.def: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | BINARYOP(add) 16 | BINARYOP(ashr) 17 | BINARYOP(band) 18 | BINARYOP(bior) 19 | BINARYOP(bxor) 20 | BINARYOP(cand) 21 | BINARYOP(cior) 22 | BINARYOP(cmp) 23 | BINARYOP(cmpl) 24 | BINARYOP(cmpg) 25 | BINARYOP(div) 26 | BINARYOP(eq) 27 | BINARYOP(gt) 28 | BINARYOP(land) 29 | BINARYOP(lior) 30 | BINARYOP(le) 31 | BINARYOP(lshr) 32 | BINARYOP(lt) 33 | BINARYOP(max) 34 | BINARYOP(min) 35 | BINARYOP(mul) 36 | BINARYOP(ne) 37 | BINARYOP(ge) 38 | BINARYOP(rem) 39 | BINARYOP(shl) 40 | BINARYOP(sub) 41 | BINARYOP(CG_array_elem_add) 42 | 43 | -------------------------------------------------------------------------------- /src/maple_ir/include/intrinsic_op.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MAPLE_IR_INCLUDE_INTRINSIC_OP_H 16 | #define MAPLE_IR_INCLUDE_INTRINSIC_OP_H 17 | 18 | namespace maple { 19 | enum MIRIntrinsicID { 20 | #define DEF_MIR_INTRINSIC(STR, NAME, INTRN_CLASS, RETURN_TYPE, ...) INTRN_##STR, 21 | #include "intrinsics.def" 22 | #undef DEF_MIR_INTRINSIC 23 | }; 24 | } // namespace maple 25 | #endif // MAPLE_IR_INCLUDE_INTRINSIC_OP_H 26 | -------------------------------------------------------------------------------- /src/maple_ir/include/memory_order_attrs.def: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | ATTR(memory_order_relaxed) 16 | ATTR(memory_order_consume) 17 | ATTR(memory_order_acquire) 18 | ATTR(memory_order_release) 19 | ATTR(memory_order_acq_rel) 20 | ATTR(memory_order_seq_cst) 21 | -------------------------------------------------------------------------------- /src/maple_ir/include/parser_opt.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MAPLE_IR_INCLUDE_PARSER_OPT_H 16 | #define MAPLE_IR_INCLUDE_PARSER_OPT_H 17 | #include "types_def.h" 18 | 19 | namespace maple { 20 | // option bits passed into ParseMIR 21 | enum ParserOptions : uint8 { 22 | kInvalidOption = 0x0, 23 | kWithDbgInfo = 0x1, // collect dbginfo 24 | kKeepFirst = 0x2, // ignore second type def, not emit error 25 | kWithProfileInfo = 0x4, 26 | kParseOptFunc = 0x08, // parse optimized function mpl file 27 | }; 28 | } // namespace maple 29 | #endif // MAPLE_IR_INCLUDE_PARSER_OPT_H 30 | -------------------------------------------------------------------------------- /src/maple_ir/include/printing.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MAPLE_IR_INCLUDE_PRINTING_H 16 | #define MAPLE_IR_INCLUDE_PRINTING_H 17 | #include 18 | #include "types_def.h" 19 | 20 | namespace maple { 21 | void PrintIndentation(int32 indent); 22 | void PrintString(const std::string &str); 23 | } // namespace maple 24 | #endif // MAPLE_IR_INCLUDE_PRINTING_H 25 | -------------------------------------------------------------------------------- /src/maple_ir/include/unary_op.def: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | UNARYOP(abs) 16 | UNARYOP(bnot) 17 | UNARYOP(lnot) 18 | UNARYOP(neg) 19 | UNARYOP(recip) 20 | UNARYOP(sqrt) 21 | UNARYOP(sext) 22 | UNARYOP(zext) 23 | UNARYOP(extractbits) 24 | UNARYOP(alloca) 25 | UNARYOP(malloc) 26 | UNARYOP(gcmallocjarray) 27 | UNARYOP(gcpermallocjarray) 28 | -------------------------------------------------------------------------------- /src/maple_ir/src/opcode_info.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #include "opcode_info.h" 16 | 17 | namespace maple { 18 | OpcodeTable::OpcodeTable() { 19 | #define STR(s) #s 20 | #define OPCODE(O, P, F, S) \ 21 | table[OP_##O].flag = F; \ 22 | table[OP_##O].name = STR(O); \ 23 | table[OP_##O].instrucSize = S; 24 | #include "opcodes.def" 25 | #undef OPCODE 26 | table[OP_maydassign].name = "dassign"; // maydassign is printed dassign 27 | } 28 | const OpcodeTable kOpcodeInfo; 29 | } // namespace maple 30 | -------------------------------------------------------------------------------- /src/maple_me/include/func_emit.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MAPLE_ME_INCLUDE_FUNC_EMIT_H 16 | #define MAPLE_ME_INCLUDE_FUNC_EMIT_H 17 | #include "bb.h" 18 | 19 | // Provide emit service for both MeFunction and WpoFunction. 20 | namespace maple { 21 | class FuncEmit { 22 | public: 23 | void EmitBeforeHSSA(MIRFunction &func, const MapleVector &bbList) const; 24 | virtual ~FuncEmit() = default; 25 | 26 | private: 27 | void EmitLabelForBB(MIRFunction &func, BB &bb) const; 28 | }; 29 | } // namespace maple 30 | #endif // MAPLE_ME_INCLUDE_FUNC_EMIT_H 31 | -------------------------------------------------------------------------------- /src/maple_me/include/me_cond_based_npc.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MAPLE_ME_INCLUDE_MECONDBASEDNPC_H 16 | #define MAPLE_ME_INCLUDE_MECONDBASEDNPC_H 17 | #include "me_cond_based.h" 18 | 19 | namespace maple { 20 | class CondBasedNPC : public MeCondBased { 21 | public: 22 | CondBasedNPC(MeFunction &func, Dominance &dom) : MeCondBased(func, dom) {} 23 | 24 | ~CondBasedNPC() = default; 25 | void DoCondBasedNPC() const; 26 | }; 27 | 28 | class MeDoCondBasedNPC : public MeFuncPhase { 29 | public: 30 | explicit MeDoCondBasedNPC(MePhaseID id) : MeFuncPhase(id) {} 31 | 32 | virtual ~MeDoCondBasedNPC() = default; 33 | AnalysisResult *Run(MeFunction *func, MeFuncResultMgr *m, ModuleResultMgr *mrm) override; 34 | std::string PhaseName() const override { 35 | return "condbasednpc"; 36 | } 37 | }; 38 | } // namespace maple 39 | #endif // MAPLE_ME_INCLUDE_MECONDBASEDNPC_H 40 | -------------------------------------------------------------------------------- /src/maple_me/include/me_cond_based_rc.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MAPLE_ME_INCLUDE_MECONDBASEDRC_H 16 | #define MAPLE_ME_INCLUDE_MECONDBASEDRC_H 17 | #include "me_cond_based.h" 18 | 19 | namespace maple { 20 | class CondBasedRC : public MeCondBased { 21 | public: 22 | CondBasedRC(MeFunction &f, Dominance &dom) : MeCondBased(f, dom) {} 23 | 24 | virtual ~CondBasedRC() = default; 25 | }; 26 | 27 | class MeDoCondBasedRC : public MeFuncPhase { 28 | public: 29 | explicit MeDoCondBasedRC(MePhaseID id) : MeFuncPhase(id) {} 30 | 31 | virtual ~MeDoCondBasedRC() = default; 32 | AnalysisResult *Run(MeFunction *func, MeFuncResultMgr *m, ModuleResultMgr *mrm) override; 33 | std::string PhaseName() const override { 34 | return "condbasedrc"; 35 | } 36 | }; 37 | } // namespace maple 38 | #endif // MAPLE_ME_INCLUDE_MECONDBASEDRC_H 39 | -------------------------------------------------------------------------------- /src/maple_me/include/me_const.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | 16 | #ifndef MAPLE_ME_INCLUDE_ME_CONST_H 17 | #define MAPLE_ME_INCLUDE_ME_CONST_H 18 | #include 19 | 20 | // define consts used by maple_me 21 | namespace maple { 22 | const std::string kStrThisPointer = "_this"; 23 | } 24 | #endif // MAPLE_ME_INCLUDE_ME_CONST_H 25 | -------------------------------------------------------------------------------- /src/maple_me/include/me_dominance.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MAPLE_ME_INCLUDE_ME_DOMINANCE_H 16 | #define MAPLE_ME_INCLUDE_ME_DOMINANCE_H 17 | #include "dominance.h" 18 | #include "me_function.h" 19 | #include "me_phase.h" 20 | 21 | namespace maple { 22 | class MeDoDominance : public MeFuncPhase { 23 | public: 24 | explicit MeDoDominance(MePhaseID id) : MeFuncPhase(id) {} 25 | 26 | ~MeDoDominance() override = default; 27 | AnalysisResult *Run(MeFunction *func, MeFuncResultMgr *funcResMgr, ModuleResultMgr *moduleResMgr) override; 28 | 29 | std::string PhaseName() const override { 30 | return "dominance"; 31 | } 32 | }; 33 | } // namespace maple 34 | #endif // MAPLE_ME_INCLUDE_ME_DOMINANCE_H 35 | -------------------------------------------------------------------------------- /src/maple_me/include/me_emit.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MAPLE_ME_INCLUDE_ME_EMIT_H 16 | #define MAPLE_ME_INCLUDE_ME_EMIT_H 17 | #include "me_function.h" 18 | #include "me_phase.h" 19 | 20 | // emit ir to specified file 21 | namespace maple { 22 | class MeDoEmit : public MeFuncPhase { 23 | public: 24 | explicit MeDoEmit(MePhaseID id) : MeFuncPhase(id) {} 25 | 26 | virtual ~MeDoEmit() = default; 27 | AnalysisResult *Run(MeFunction *func, MeFuncResultMgr *funcResMgr, ModuleResultMgr *moduleResMgr) override; 28 | std::string PhaseName() const override { 29 | return "emit"; 30 | } 31 | }; 32 | } // namespace maple 33 | #endif // MAPLE_ME_INCLUDE_ME_EMIT_H 34 | -------------------------------------------------------------------------------- /src/maple_me/include/me_lower_globals.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MAPLE_ME_INCLUDE_MELOWERGLOBALS_H 16 | #define MAPLE_ME_INCLUDE_MELOWERGLOBALS_H 17 | #include "me_function.h" 18 | #include "me_irmap.h" 19 | 20 | namespace maple { 21 | class MeLowerGlobals { 22 | public: 23 | MeLowerGlobals(MeFunction &func, SSATab *ssaTab) : func(func), irMap(func.GetIRMap()), ssaTable(ssaTab) {} 24 | ~MeLowerGlobals() = default; 25 | void Run(); 26 | 27 | private: 28 | MeFunction &func; 29 | IRMap *irMap; 30 | SSATab *ssaTable; 31 | void LowerGlobalDreads(MeStmt &stmt, MeExpr &expr); 32 | }; 33 | } // namespace maple 34 | #endif // MAPLE_ME_INCLUDE_MELOWERGLOBALS_H 35 | -------------------------------------------------------------------------------- /src/maple_me/include/me_may2dassign.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MAPLE_ME_INCLUDE_MEMAY2DASSIGN_H 16 | #define MAPLE_ME_INCLUDE_MEMAY2DASSIGN_H 17 | #include "me_function.h" 18 | #include "me_phase.h" 19 | #include "me_irmap.h" 20 | 21 | namespace maple { 22 | class May2Dassign { 23 | public: 24 | explicit May2Dassign(MeFunction &func) : func(func), irMap(func.GetIRMap()), ssaTab(func.GetMeSSATab()) {} 25 | 26 | ~May2Dassign() = default; 27 | void DoIt(); 28 | 29 | private: 30 | MeFunction &func; 31 | IRMap *irMap; 32 | SSATab *ssaTab; 33 | }; 34 | 35 | class MeDoMay2Dassign : public MeFuncPhase { 36 | public: 37 | explicit MeDoMay2Dassign(MePhaseID id) : MeFuncPhase(id) {} 38 | 39 | virtual ~MeDoMay2Dassign() = default; 40 | AnalysisResult *Run(MeFunction *func, MeFuncResultMgr *m, ModuleResultMgr *mrm) override; 41 | std::string PhaseName() const override { 42 | return "may2dassign"; 43 | } 44 | }; 45 | } // namespace maple 46 | #endif // MAPLE_ME_INCLUDE_MEMAY2DASSIGN_H 47 | -------------------------------------------------------------------------------- /src/maple_me/include/me_rename2preg.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MAPLE_ME_INCLUDE_MERENAME2PREG_H 16 | #define MAPLE_ME_INCLUDE_MERENAME2PREG_H 17 | #include "me_phase.h" 18 | #include "me_function.h" 19 | 20 | namespace maple { 21 | class MeDoSSARename2Preg : public MeFuncPhase { 22 | public: 23 | explicit MeDoSSARename2Preg(MePhaseID id) : MeFuncPhase(id) {} 24 | 25 | virtual ~MeDoSSARename2Preg() = default; 26 | AnalysisResult *Run(MeFunction *func, MeFuncResultMgr *funcRst, ModuleResultMgr*) override; 27 | std::string PhaseName() const override; 28 | }; 29 | } // namespace maple 30 | #endif // MAPLE_ME_INCLUDE_MERENAME2PREG_H 31 | -------------------------------------------------------------------------------- /src/maple_me/include/me_ssa_tab.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MAPLE_ME_INCLUDE_ME_SSA_TAB_H 16 | #define MAPLE_ME_INCLUDE_ME_SSA_TAB_H 17 | #include "me_function.h" 18 | #include "me_phase.h" 19 | 20 | namespace maple { 21 | class MeDoSSATab : public MeFuncPhase { 22 | public: 23 | explicit MeDoSSATab(MePhaseID id) : MeFuncPhase(id) {} 24 | 25 | virtual ~MeDoSSATab() = default; 26 | 27 | private: 28 | AnalysisResult *Run(MeFunction *func, MeFuncResultMgr *funcResMgr, ModuleResultMgr *moduleResMgr) override; 29 | std::string PhaseName() const override { 30 | return "ssatab"; 31 | } 32 | }; 33 | } // namespace maple 34 | #endif // MAPLE_ME_INCLUDE_ME_SSA_TAB_H 35 | -------------------------------------------------------------------------------- /src/maple_util/include/error_code.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MAPLE_UTIL_INCLUDE_ERROR_CODE_H 16 | #define MAPLE_UTIL_INCLUDE_ERROR_CODE_H 17 | 18 | #include 19 | 20 | namespace maple { 21 | enum ErrorCode { 22 | kErrorNoError, 23 | kErrorExit, 24 | kErrorExitHelp, 25 | kErrorInvalidParameter, 26 | kErrorInitFail, 27 | kErrorFileNotFound, 28 | kErrorToolNotFound, 29 | kErrorCompileFail, 30 | kErrorNotImplement 31 | }; 32 | 33 | void PrintErrorMessage(int ret); 34 | } // namespace maple 35 | #endif // MAPLE_UTIL_INCLUDE_ERROR_CODE_H 36 | -------------------------------------------------------------------------------- /src/maple_util/include/file_layout.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MAPLE_UTIL_INCLUDE_FILE_LAYOUT_H 16 | #define MAPLE_UTIL_INCLUDE_FILE_LAYOUT_H 17 | #include 18 | 19 | namespace maple { 20 | // file-layout is shared between maple compiler and runtime, thus not in namespace maplert 21 | enum LayoutType : uint8_t { 22 | kLayoutBootHot, 23 | kLayoutBothHot, 24 | kLayoutRunHot, 25 | kLayoutStartupOnly, 26 | kLayoutUsedOnce, 27 | kLayoutExecuted, // method excuted in some condition 28 | kLayoutUnused, 29 | kLayoutTypeCount 30 | }; 31 | 32 | // this used for c string layout 33 | static uint8_t kCStringShift = 1; 34 | std::string GetLayoutTypeString(uint32_t type); 35 | } // namespace maple 36 | #endif 37 | -------------------------------------------------------------------------------- /src/maple_util/include/itab_util.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MAPLE_UTIL_INCLUDE_ITAB_UTIL_H 16 | #define MAPLE_UTIL_INCLUDE_ITAB_UTIL_H 17 | 18 | namespace maple { 19 | constexpr int kHashSize = 23; 20 | constexpr int kHeadSizeOfSecondHash = 3; 21 | constexpr int kFlagAgInHeadOfSecondHash = 1; 22 | constexpr unsigned int kItabSecondHashSize = 0x1fff; 23 | constexpr int kFlagFirstHashConflict = 0; 24 | constexpr int kFlagSecondHashConflict = 1; 25 | 26 | constexpr int kItabFirstHashSize = kHashSize; 27 | 28 | unsigned int DJBHash(const char *str); 29 | unsigned int GetHashIndex(const char *name); 30 | unsigned int GetSecondHashIndex(const char *name); 31 | 32 | } // namespace maple 33 | #endif 34 | -------------------------------------------------------------------------------- /src/maple_util/include/mpl_timer.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MAPLE_UTIL_INCLUDE_MPL_TIMER_H 16 | #define MAPLE_UTIL_INCLUDE_MPL_TIMER_H 17 | 18 | #include 19 | 20 | namespace maple { 21 | class MPLTimer { 22 | public: 23 | MPLTimer(); 24 | ~MPLTimer(); 25 | void Start(); 26 | void Stop(); 27 | long Elapsed(); 28 | long ElapsedMilliseconds(); 29 | long ElapsedMicroseconds(); 30 | 31 | private: 32 | std::chrono::system_clock::time_point startTime; 33 | std::chrono::system_clock::time_point endTime; 34 | }; 35 | } // namespace maple 36 | #endif // MAPLE_UTIL_INCLUDE_MPL_TIMER_H 37 | -------------------------------------------------------------------------------- /src/maple_util/include/version.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MAPLE_UTIL_INCLUDE_VERSION_H 16 | #define MAPLE_UTIL_INCLUDE_VERSION_H 17 | 18 | namespace Version { 19 | static constexpr const int kMajorMplVersion = 4; 20 | static constexpr const int kMinorCompilerVersion = 0; 21 | static constexpr const int kMinorRuntimeVersion = 0; 22 | } 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /src/mplfe/common/include/base64.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MPLFE_INCLUDE_COMMON_BASE64_H 16 | #define MPLFE_INCLUDE_COMMON_BASE64_H 17 | #include 18 | #include 19 | #include "types_def.h" 20 | 21 | namespace maple { 22 | class Base64 { 23 | public: 24 | static std::string Encode(const uint8 *input, size_t length); 25 | static uint8 *Decode(const std::string &input, size_t &lengthRet); 26 | static std::map InitEncodeMap(); 27 | static std::map InitDecodeMap(); 28 | 29 | private: 30 | Base64() = default; 31 | ~Base64() = default; 32 | 33 | static std::map encodeMap; 34 | static std::map decodeMap; 35 | static size_t DecodeLength(const std::string &input); 36 | }; 37 | } // namespace maple 38 | #endif -------------------------------------------------------------------------------- /src/mplfe/common/include/fe_configs.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MPLFE_INCLUDE_COMMON_FE_CONFIGS_H 16 | #define MPLFE_INCLUDE_COMMON_FE_CONFIGS_H 17 | #include "types_def.h" 18 | 19 | #if ENABLE_COV_CHECK == 1 20 | #define LLT_MOCK_TARGET virtual 21 | #define LLT_MOCK_TARGET_VIRTUAL virtual 22 | #define LLT_PUBLIC public 23 | #define LLT_PROTECTED public 24 | #define LLT_PRIVATE public 25 | #else 26 | #define LLT_MOCK_TARGET 27 | #define LLT_MOCK_TARGET_VIRTUAL virtual 28 | #define LLT_PUBLIC public 29 | #define LLT_PROTECTED protected 30 | #define LLT_PRIVATE private 31 | #endif 32 | 33 | namespace maple { 34 | using TypeDim = uint8; 35 | 36 | class FEConstants { 37 | public: 38 | const static uint8 kDimMax = UINT8_MAX; 39 | }; // class FEContants 40 | } // namespace maple 41 | 42 | #include "fe_config_parallel.h" 43 | #endif // MPLFE_INCLUDE_COMMON_FE_CONFIGS_H -------------------------------------------------------------------------------- /src/mplfe/common/include/fe_errno.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MPLFE_INCLUDE_COMMON_FE_ERRNO_H 16 | #define MPLFE_INCLUDE_COMMON_FE_ERRNO_H 17 | 18 | namespace maple { 19 | enum FEErrno { 20 | kNoError = 0, 21 | kCmdParseError = 1, 22 | kNoValidInput = 2, 23 | }; 24 | } // namespace maple 25 | #endif // ~MPLFE_INCLUDE_COMMON_MPLFE_ERRNO_H -------------------------------------------------------------------------------- /src/mplfe/common/include/fe_file_ops.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MPLFE_INCLUDE_COMMON_FE_FILE_OPS_H 16 | #define MPLFE_INCLUDE_COMMON_FE_FILE_OPS_H 17 | #include 18 | 19 | namespace maple { 20 | class FEFileOps { 21 | public: 22 | static std::string GetFilePath(const std::string &pathName); 23 | static std::string GetFileNameWithExt(const std::string &pathName); 24 | static std::string GetFileName(const std::string &pathName); 25 | static std::string GetFileExtName(const std::string &pathName); 26 | 27 | private: 28 | FEFileOps() = default; 29 | ~FEFileOps() = default; 30 | }; 31 | } // namespace maple 32 | #endif -------------------------------------------------------------------------------- /src/mplfe/common/include/fe_timer_ns.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MPLFE_INCLUDE_COMMON_FE_TIMER_NS_H 16 | #define MPLFE_INCLUDE_COMMON_FE_TIMER_NS_H 17 | #include 18 | #include 19 | #include 20 | 21 | namespace maple { 22 | class FETimerNS { 23 | public: 24 | FETimerNS() = default; 25 | ~FETimerNS() = default; 26 | void Start(); 27 | void Stop(); 28 | int64_t GetTimeNS() const; 29 | 30 | private: 31 | struct timespec timeStart = {0, 0}; 32 | struct timespec timeEnd = {0, 0}; 33 | }; // class FETimerNS 34 | } // namespace maple 35 | #endif // MPLFE_INCLUDE_COMMON_FE_TIMER_NS_H -------------------------------------------------------------------------------- /src/mplfe/common/include/fe_type_hierarchy.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MPLFE_INCLUDE_FE_TYPE_HIERARCHY_H 16 | #define MPLFE_INCLUDE_FE_TYPE_HIERARCHY_H 17 | #include 18 | #include 19 | #include "mir_type.h" 20 | 21 | namespace maple { 22 | class FETypeHierarchy { 23 | public: 24 | static FETypeHierarchy &GetInstance() { 25 | return instance; 26 | } 27 | void InitByGlobalTable(); 28 | void AddMIRType(const MIRClassType &type); 29 | void AddMIRType(const MIRInterfaceType &type); 30 | bool IsParentOf(const GStrIdx &parentIdx, const GStrIdx &childIdx); 31 | 32 | private: 33 | static FETypeHierarchy instance; 34 | std::map> mapIdxChildParent; 35 | std::set> cache; 36 | FETypeHierarchy() = default; 37 | ~FETypeHierarchy() = default; 38 | void AddParentChildRelation(const GStrIdx &parentIdx, const GStrIdx &childIdx); 39 | }; // class FETypeHierarchy 40 | } // namespace maple 41 | #endif // MPLFE_INCLUDE_FE_TYPE_HIERARCHY_H -------------------------------------------------------------------------------- /src/mplfe/common/include/fe_utils_java.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MPLFE_INCLUDE_FE_UTILS_JAVA_H 16 | #define MPLFE_INCLUDE_FE_UTILS_JAVA_H 17 | #include 18 | #include 19 | #include "feir_type.h" 20 | 21 | namespace maple { 22 | class FEUtilJava { 23 | public: 24 | static std::vector SolveMethodSignature(std::string signature, bool inMpl = true); 25 | static std::string SolveParamNameInJavaFormat(const std::string &signature); 26 | 27 | private: 28 | FEUtilJava() = default; 29 | ~FEUtilJava() = default; 30 | }; 31 | } // namespace maple 32 | #endif // MPLFE_INCLUDE_FE_UTILS_JAVA_H -------------------------------------------------------------------------------- /src/mplfe/common/include/feir_bb.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MPLFE_INCLUDE_COMMON_FEIR_BB_H 16 | #define MPLFE_INCLUDE_COMMON_FEIR_BB_H 17 | #include 18 | #include "types_def.h" 19 | #include "mempool_allocator.h" 20 | #include "fe_configs.h" 21 | #include "fe_utils.h" 22 | #include "feir_stmt.h" 23 | #include "general_bb.h" 24 | 25 | namespace maple { 26 | class FEIRBB : public GeneralBB { 27 | public: 28 | FEIRBB(MapleAllocator &allocator, uint8 argKind); 29 | virtual ~FEIRBB() = default; 30 | }; // class FEIRBB 31 | } // namespace maple 32 | #endif // MPLFE_INCLUDE_COMMON_FEIR_BB_H -------------------------------------------------------------------------------- /src/mplfe/common/include/feir_dfg.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MPLFE_INCLUDE_FEIR_DFG_H 16 | #define MPLFE_INCLUDE_FEIR_DFG_H 17 | #include "feir_var.h" 18 | 19 | namespace maple { 20 | class FEIRDFG { 21 | public: 22 | FEIRDFG() = default; 23 | ~FEIRDFG() = default; 24 | static void CalculateDefUseByUseDef(std::map> &mapDefUse, 25 | const std::map> &mapUseDef); 26 | static void CalculateUseDefByDefUse(std::map> &mapUseDef, 27 | const std::map> &mapDefUse); 28 | }; 29 | } // namespace maple 30 | #endif // MPLFE_INCLUDE_FEIR_DFG_H -------------------------------------------------------------------------------- /src/mplfe/common/src/fe_config_parallel.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #include "fe_config_parallel.h" 16 | #include "mpl_logging.h" 17 | 18 | namespace maple { 19 | FEConfigParallel FEConfigParallel::instance; 20 | 21 | FEConfigParallel::FEConfigParallel() 22 | : nThread(1), enableParallel(false) {} 23 | } // namespace maple -------------------------------------------------------------------------------- /src/mplfe/common/src/fe_manager.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #include "fe_manager.h" 16 | 17 | namespace maple { 18 | FEManager *FEManager::manager = nullptr; 19 | } // namespace maple -------------------------------------------------------------------------------- /src/mplfe/common/src/fe_timer_ns.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #include "fe_timer_ns.h" 16 | #include "types_def.h" 17 | 18 | namespace maple { 19 | void FETimerNS::Start() { 20 | (void)clock_gettime(CLOCK_REALTIME, &timeStart); 21 | } 22 | 23 | void FETimerNS::Stop() { 24 | (void)clock_gettime(CLOCK_REALTIME, &timeEnd); 25 | } 26 | 27 | int64_t FETimerNS::GetTimeNS() const { 28 | const int64 nsInS = 1000000000; 29 | return nsInS * (timeEnd.tv_sec - timeStart.tv_sec) + (timeEnd.tv_nsec - timeStart.tv_nsec); 30 | } 31 | } // namespace maple 32 | -------------------------------------------------------------------------------- /src/mplfe/doc/mplfe_guide.md: -------------------------------------------------------------------------------- 1 | # FE前端框架使用手册 2 | [TOC] 3 | 4 | ## 附录A. 并行编程规范 5 | ### A.1. 并行过程中不可使用的操作 6 | FE前端框架使用多线程并行, 为了保证高效性, 不可以使用以下的操作: 7 | * 写入```GlobalTable``` 8 | * 使用```MemPool```进行对象创建 9 | 10 | ### A.2. 规范守护框架 11 | FE前端框架提供宏进行并行可行性检测, 具体使用步骤如下 12 | 1. 添加头文件```fe_config_parallel.h``` 13 | 2. 根据A.1.的规范进行函数并行可行性判断, 如果不可以并行, 在函数入口处添加宏调用```MPLFE_PARALLEL_FORBIDDEN()``` 14 | 15 | 如果在并行过程中调用了宏```MPLFE_PARALLEL_FORBIDDEN()```, 则会引发```CHECK_FATAL```错误, 并打印调用点的行号. 16 | 注: ```-np 1```也是并行调用过程, 使用1个```Run```线程加1个```Finish```线程. 17 | -------------------------------------------------------------------------------- /src/mplfe/jbc_input/include/jbc_class_builder.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MPLFE_INCLUDE_JBC_CLASS_BUILDER_H 16 | #define MPLFE_INCLUDE_JBC_CLASS_BUILDER_H 17 | #include "jbc_class.h" 18 | 19 | namespace maple { 20 | namespace jbc { 21 | class JBCClassBuilder { 22 | public: 23 | JBCClassBuilder() = default; 24 | ~JBCClassBuilder() = default; 25 | 26 | public: 27 | }; 28 | } // namespace jbc 29 | } // namespace maple 30 | #endif // MPLFE_INCLUDE_JBC_CLASS_BUILDER_H -------------------------------------------------------------------------------- /src/mplfe/jbc_input/include/jbc_class_const.def: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | // JBC_CONST(tag, tagName, className) 16 | JBC_CONST(kConstUTF8, "ConstUTF8", JBCConstUTF8) 17 | JBC_CONST(kConstInteger, "ConstInteger", JBCConst4Byte) 18 | JBC_CONST(kConstFloat, "ConstFloat", JBCConst4Byte) 19 | JBC_CONST(kConstLong, "ConstLong", JBCConst8Byte) 20 | JBC_CONST(kConstDouble, "ConstDouble", JBCConst8Byte) 21 | JBC_CONST(kConstClass, "ConstClass", JBCConstClass) 22 | JBC_CONST(kConstString, "ConstString", JBCConstString) 23 | JBC_CONST(kConstFieldRef, "ConstFieldRef", JBCConstRef) 24 | JBC_CONST(kConstMethodRef, "ConstMethodRef", JBCConstRef) 25 | JBC_CONST(kConstInterfaceMethodRef, "ConstInterfaceMethodRef", JBCConstRef) 26 | JBC_CONST(kConstNameAndType, "ConstNameAndType", JBCConstNameAndType) 27 | JBC_CONST(kConstMethodHandleInfo, "ConstMethodHandleInfo", JBCConstMethodHandleInfo) 28 | JBC_CONST(kConstMethodType, "ConstMethodType", JBCConstMethodType) 29 | JBC_CONST(kConstInvokeDynamic, "ConstInvokeDynamic", JBCConstInvokeDynamic) -------------------------------------------------------------------------------- /src/mplfe/jbc_input/include/jbc_class_header.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MPLFE_INCLUDE_JBC_CLASS_HEADER_H 16 | #define MPLFE_INCLUDE_JBC_CLASS_HEADER_H 17 | #include "types_def.h" 18 | #include "basic_io.h" 19 | 20 | namespace maple { 21 | namespace jbc { 22 | class JBCClassHeader { 23 | public: 24 | JBCClassHeader(); 25 | ~JBCClassHeader() = default; 26 | bool ParseClassFile(BasicIORead &io) const; 27 | 28 | private: 29 | uint32 magic; 30 | uint16 minorVersion; 31 | uint16 majorVersion; 32 | uint16 constPoolCount; 33 | uint16 accessFlag; 34 | uint16 thisClass; 35 | uint16 superClass; 36 | uint16 interfacesCount; 37 | uint16 fieldsCount; 38 | uint16 methodsCount; 39 | uint16 attrsCount; 40 | }; 41 | } // namespace jbc 42 | } // namespace maple 43 | #endif -------------------------------------------------------------------------------- /src/mplfe/jbc_input/include/jbc_util.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MPLFE_INCLUDE_JBC_UTIL_H 16 | #define MPLFE_INCLUDE_JBC_UTIL_H 17 | #include 18 | #include 19 | #include "jbc_opcode.h" 20 | 21 | namespace maple { 22 | namespace jbc { 23 | class JBCUtil { 24 | public: 25 | static std::string ClassInternalNameToFullName(const std::string &name); 26 | static std::vector SolveMethodSignature(const std::string &signature); 27 | static std::string SolveParamName(const std::string &signature); 28 | static JBCPrimType GetPrimTypeForName(const std::string &name); 29 | 30 | private: 31 | JBCUtil() = default; 32 | ~JBCUtil() = default; 33 | }; 34 | } // namespace jbc 35 | } // namespace maple 36 | #endif // MPLFE_INCLUDE_JBC_UTIL_H -------------------------------------------------------------------------------- /src/mplfe/jbc_input/src/jbc_class_header.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #include "jbc_class_header.h" 16 | namespace maple { 17 | namespace jbc { 18 | JBCClassHeader::JBCClassHeader() 19 | : magic(0), 20 | minorVersion(0), 21 | majorVersion(0), 22 | constPoolCount(0), 23 | accessFlag(0), 24 | thisClass(0), 25 | superClass(0), 26 | interfacesCount(0), 27 | fieldsCount(0), 28 | methodsCount(0), 29 | attrsCount(0) {} 30 | 31 | bool JBCClassHeader::ParseClassFile(BasicIORead &io) const { 32 | return false; 33 | } 34 | } // namespace jbc 35 | } // namespace maple -------------------------------------------------------------------------------- /src/mplfe/test/fe_utils_test.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #include 16 | #include 17 | #include "fe_utils.h" 18 | 19 | namespace maple { 20 | TEST(FEUtils, Split) { 21 | std::string str = "A,B,C"; 22 | std::vector results = FEUtils::Split(str, ','); 23 | ASSERT_EQ(results.size(), 3); 24 | EXPECT_EQ(results[0], "A"); 25 | EXPECT_EQ(results[1], "B"); 26 | EXPECT_EQ(results[2], "C"); 27 | } 28 | } // namespace maple -------------------------------------------------------------------------------- /src/mplfe/test/feir_test_base.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #include "feir_test_base.h" 16 | #include "mplfe_ut_environment.h" 17 | 18 | namespace maple { 19 | MemPool *FEIRTestBase::mp = nullptr; 20 | 21 | FEIRTestBase::FEIRTestBase() 22 | : allocator(mp), 23 | mirBuilder(&MPLFEUTEnvironment::GetMIRModule()), 24 | func(&MPLFEUTEnvironment::GetMIRModule(), StIdx(0, 0)) { 25 | func.Init(); 26 | mirBuilder.SetCurrentFunction(func); 27 | } 28 | 29 | void FEIRTestBase::SetUpTestCase() { 30 | mp = memPoolCtrler.NewMemPool("MemPool for FEIRTestBase"); 31 | } 32 | 33 | void FEIRTestBase::TearDownTestCase() { 34 | memPoolCtrler.DeleteMemPool(mp); 35 | mp = nullptr; 36 | } 37 | } // namespace maple -------------------------------------------------------------------------------- /src/mplfe/test/feir_test_base.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #include 16 | #include 17 | #include "redirect_buffer.h" 18 | #include "global_tables.h" 19 | #include "mir_module.h" 20 | #include "mir_builder.h" 21 | 22 | namespace maple { 23 | class FEIRTestBase : public testing::Test, public RedirectBuffer { 24 | public: 25 | static MemPool *mp; 26 | MapleAllocator allocator; 27 | MIRBuilder mirBuilder; 28 | MIRFunction func; 29 | FEIRTestBase(); 30 | virtual ~FEIRTestBase() = default; 31 | 32 | static void SetUpTestCase(); 33 | static void TearDownTestCase(); 34 | }; 35 | } // namespace maple -------------------------------------------------------------------------------- /src/mplfe/test/jbc_class_const_test.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #include 16 | #include 17 | #include "jbc_class_const.h" 18 | 19 | namespace maple { 20 | namespace jbc { 21 | TEST(JBCClassConst, GetTagName) { 22 | EXPECT_EQ(JBCConstTagName::GetTagName(kConstUTF8), "ConstUTF8"); 23 | } 24 | } // namespace jbc 25 | } // namespace maple -------------------------------------------------------------------------------- /src/mplfe/test/jbc_input/JBC0001/Test.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/c2s/OpenArkCompiler/1755550ea22eb185cbef8cc5864fa273caebf95a/src/mplfe/test/jbc_input/JBC0001/Test.class -------------------------------------------------------------------------------- /src/mplfe/test/jbc_input/JBC0001/Test.java: -------------------------------------------------------------------------------- 1 | public class Test { 2 | public int v1 = 0x12345678; 3 | public static long v2 = 0x1234567890l; 4 | public float v3 = 16.0f; 5 | public static double v4 = -16.0; 6 | 7 | public void func1() { 8 | } 9 | 10 | public static void func2() { 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /src/mplfe/test/jbc_util_test.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #include 16 | #include 17 | #include "jbc_util.h" 18 | 19 | namespace maple { 20 | namespace jbc { 21 | TEST(JBCUtil, ClassInternalNameToFullName) { 22 | EXPECT_EQ(JBCUtil::ClassInternalNameToFullName("java/lang/Object"), "Ljava/lang/Object;"); 23 | EXPECT_EQ(JBCUtil::ClassInternalNameToFullName("[Ljava/lang/Object;"), "[Ljava/lang/Object;"); 24 | } 25 | 26 | TEST(JBCUtil, SolveMethodSignature) { 27 | std::vector ans; 28 | ans = JBCUtil::SolveMethodSignature("func(Ljava/lang/Object;[II)J"); 29 | ASSERT_EQ(ans.size(), 4); 30 | EXPECT_EQ(ans[0], "J"); 31 | EXPECT_EQ(ans[1], "Ljava/lang/Object;"); 32 | EXPECT_EQ(ans[2], "[I"); 33 | EXPECT_EQ(ans[3], "I"); 34 | } 35 | } // namespace jbc 36 | } // namespace maple -------------------------------------------------------------------------------- /src/mplfe/test/mplfe_ut.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MPLFEUT_INCLUDE_MPLFE_UT_H 16 | #define MPLFEUT_INCLUDE_MPLFE_UT_H 17 | #include "mir_module.h" 18 | 19 | extern maple::MIRModule &module; 20 | extern MPLFEUTOptions &options; 21 | #endif // MPLFEUT_INCLUDE_MPLFE_UT_H -------------------------------------------------------------------------------- /src/mplfe/test/mplfe_ut_environment.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MPLFE_TEST_MPLFE_UT_ENVIRONMENT_H 16 | #define MPLFE_TEST_MPLFE_UT_ENVIRONMENT_H 17 | #include 18 | #include 19 | #include "global_tables.h" 20 | #include "mir_module.h" 21 | 22 | namespace maple { 23 | class MPLFEUTEnvironment : public ::testing::Environment { 24 | public: 25 | MPLFEUTEnvironment() = default; 26 | ~MPLFEUTEnvironment() = default; 27 | 28 | static MIRModule &GetMIRModule() { 29 | static MIRModule module("mplfeUT"); 30 | return module; 31 | } 32 | 33 | void SetUp() override { 34 | theMIRModule = &GetMIRModule(); 35 | } 36 | }; 37 | } // namespace maple 38 | #endif // MPLFE_TEST_MPLFE_UT_ENVIRONMENT_H -------------------------------------------------------------------------------- /src/mplfe/test/mplfe_ut_regx.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #include "mplfe_ut_regx.h" 16 | #include 17 | #include 18 | 19 | namespace maple { 20 | bool MPLFEUTRegx::Match(const std::string &str, const std::string &pattern) { 21 | if (std::regex_match(str, std::regex(pattern))) { 22 | return true; 23 | } else { 24 | std::cerr << "Pattern: " << pattern << std::endl; 25 | std::cerr << "String: " << str << std::endl; 26 | return false; 27 | } 28 | } 29 | 30 | std::string MPLFEUTRegx::RegName(uint32 regNum) { 31 | std::stringstream ss; 32 | if (regNum == kAnyNumber) { 33 | ss << "Reg[0-9]+"; 34 | } else { 35 | ss << "Reg" << regNum; 36 | } 37 | return ss.str(); 38 | } 39 | 40 | std::string MPLFEUTRegx::RefIndex(uint32 typeIdx) { 41 | std::stringstream ss; 42 | if (typeIdx == kAnyNumber) { 43 | ss << "R[0-9]+"; 44 | } else { 45 | ss << "R" << typeIdx; 46 | } 47 | return ss.str(); 48 | } 49 | } // namespace maple -------------------------------------------------------------------------------- /src/mplfe/test/mplfe_ut_regx.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #ifndef MPLFE_UT_INCLUDE_MPLFE_UT_REGX_H 16 | #define MPLFE_UT_INCLUDE_MPLFE_UT_REGX_H 17 | #include 18 | #include 19 | #include "types_def.h" 20 | 21 | namespace maple { 22 | class MPLFEUTRegx { 23 | public: 24 | static const uint32 kAnyNumber = 0xFFFFFFFF; 25 | MPLFEUTRegx() = default; 26 | ~MPLFEUTRegx() = default; 27 | static bool Match(const std::string &str, const std::string &pattern); 28 | static std::string RegName(uint32 regNum); 29 | static std::string RefIndex(uint32 typeIdx); 30 | static std::string Any() { 31 | return "(.|\r|\n)*"; 32 | } 33 | }; 34 | } // namespace maple 35 | #endif // MPLFE_UT_INCLUDE_MPLFE_UT_REGX_H -------------------------------------------------------------------------------- /src/mplfe/test/ops_ut_check.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | # 3 | # Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 4 | # 5 | # OpenArkCompiler is licensed under the Mulan PSL v1. 6 | # You can use this software according to the terms and conditions of the Mulan PSL v1. 7 | # You may obtain a copy of Mulan PSL v1 at: 8 | # 9 | # http://license.coscl.org.cn/MulanPSL 10 | # 11 | # THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 12 | # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 13 | # FIT FOR A PARTICULAR PURPOSE. 14 | # See the Mulan PSL v1 for more details. 15 | # 16 | set -e 17 | 18 | JAVA_CORE=${MAPLE_ROOT}/libjava-core/java-core.jar 19 | cd ${MAPLE_ROOT}/libjava-core 20 | ${MAPLE_ROOT}/output/bin/mplfe ${JAVA_CORE} -t -o java-core 21 | cd - 22 | rm -rf ${MAPLE_ROOT}/report 23 | ${MAPLE_ROOT}/output/bin/mplfeUT ext -gen-base64 ${MAPLE_ROOT}/src/mplfe/test/jbc_input/JBC0001/Test.class 24 | ${MAPLE_ROOT}/output/bin/mplfeUT ext -in-class ${MAPLE_ROOT}/src/mplfe/test/jbc_input/JBC0001/Test.class 25 | ${MAPLE_ROOT}/output/bin/mplfeUT ext -in-jar ${JAVA_CORE} 26 | ${MAPLE_ROOT}/output/bin/mplfeUT ext -mplt ${MAPLE_ROOT}/libjava-core/java-core.mplt 27 | ${MAPLE_ROOT}/output/bin/mplfeUT testWithMplt ${MAPLE_ROOT}/libjava-core/java-core.mplt 28 | 29 | -------------------------------------------------------------------------------- /test/main.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python3 2 | # -*- coding:utf-8 -*- 3 | # 4 | # Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 5 | # 6 | # OpenArkCompiler is licensed under the Mulan PSL v1. 7 | # You can use this software according to the terms and conditions of the Mulan PSL v1. 8 | # You may obtain a copy of Mulan PSL v1 at: 9 | # 10 | # http://license.coscl.org.cn/MulanPSL 11 | # 12 | # THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 13 | # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 14 | # FIT FOR A PARTICULAR PURPOSE. 15 | # See the Mulan PSL v1 for more details. 16 | # 17 | from maple_test import main 18 | 19 | if __name__ == "__main__": 20 | main() 21 | -------------------------------------------------------------------------------- /test/maple_test/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python3 2 | # -*- coding:utf-8 -*- 3 | # 4 | # Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 5 | # 6 | # OpenArkCompiler is licensed under the Mulan PSL v1. 7 | # You can use this software according to the terms and conditions of the Mulan PSL v1. 8 | # You may obtain a copy of Mulan PSL v1 at: 9 | # 10 | # http://license.coscl.org.cn/MulanPSL 11 | # 12 | # THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 13 | # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 14 | # FIT FOR A PARTICULAR PURPOSE. 15 | # See the Mulan PSL v1 for more details. 16 | # 17 | from .main import main 18 | -------------------------------------------------------------------------------- /test/maple_test/maple_test.cfg: -------------------------------------------------------------------------------- 1 | # 测试框架配置文件，当前框架仅支持通过配置文件配置测试套，测试运行时的临时路径，测试日志的保存 2 | [test-home] 3 | # 指定测试套路径，以‘：’划分 4 | dir = 5 | ../testsuite/irbuild_test: 6 | 7 | [running] 8 | #指定运行时的临时路径 9 | temp_dir = ../test_temp/run 10 | 11 | [logging] 12 | #指定运行时保存日志的路径 13 | name = ../test_temp/log 14 | level = INFO -------------------------------------------------------------------------------- /test/maple_test/template.cfg: -------------------------------------------------------------------------------- 1 | # template.cfg： 测试套模板配置文件，编写测试套时，可参考该文件，注意测试套下的配置文件名应为test.cfg 2 | # 当前主要由三个部分组成： 3 | # suffix: 测试用例后缀和测试用例中的注释符 4 | # internal-val: 测试用例中的内置变量，变量名由支持字符串和下划线构成，运行时将替换，例如：%swarn -S 2.c -o - ==》 gcc -S 2.c -o - 5 | # description: 测试套描述 6 | 7 | [suffix] 8 | s=// 9 | c=// 10 | 11 | [internal-var] 12 | swarn=gcc 13 | 14 | [description] 15 | title=C Test 16 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0001-mapleall-irbuild-edge-addf32/Main.mpl: -------------------------------------------------------------------------------- 1 | func &addf32r( 2 | var %i f32, var %j f32 3 | ) f32 { 4 | return ( 5 | add f32(dread f32 %i, dread f32 %j))} 6 | 7 | func &addf32I ( 8 | var %i f32 9 | ) f32 { 10 | return ( 11 | add f32(dread f32 %i, 12 | constval f32 1.234f))} 13 | # EXEC: %irbuild Main.mpl 14 | # EXEC: %irbuild Main.irb.mpl 15 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 16 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0002-mapleall-irbuild-edge-addi64/Main.mpl: -------------------------------------------------------------------------------- 1 | func $fooi64 ( 2 | var %i i64, var %j i64 3 | ) i64 { 4 | return ( 5 | add i64(dread i64 %i, dread i64 %j))} 6 | 7 | func $addi64I ( 8 | var %i i64 9 | ) i64 { 10 | return ( 11 | #add i64(dread i64 %i, constval i64 0x123456789))} 12 | add i64(dread i64 %i, constval i64 0x800000115))} 13 | # EXEC: %irbuild Main.mpl 14 | # EXEC: %irbuild Main.irb.mpl 15 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 16 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0003-mapleall-irbuild-edge-addi/Main.mpl: -------------------------------------------------------------------------------- 1 | func $foo1 ( 2 | var %i i32, var %j i32 3 | ) i32 { 4 | return ( 5 | add i32(dread i32 %i, dread i32 %j))} 6 | 7 | func $addi32I ( 8 | var %i i32 9 | ) i32 { 10 | return ( 11 | add i32(dread i32 %i, 12 | #constval i32 0xfff))} 13 | # constval i32 0xffff))} 14 | constval i32 0xfffff))} 15 | # EXEC: %irbuild Main.mpl 16 | # EXEC: %irbuild Main.irb.mpl 17 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 18 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0005-mapleall-irbuild-edge-arrayadd/Main.mpl: -------------------------------------------------------------------------------- 1 | var $arr1 <[10] i32> 2 | var $arr2 <[10] i32> 3 | var $arr3 <[10] i32> 4 | 5 | func $ArrayAdd () void { 6 | var %i i32 7 | doloop %i ( 8 | constval i32 0, 9 | lt i32 i32 (dread i32 %i, constval i32 10), 10 | add i32(dread i32 %i, constval i32 1)){ 11 | iassign <* [10] i32>( 12 | array 1 a32 <* [10] i32>(addrof a32 $arr1, dread i32 %i), 13 | add i32( 14 | iread i32 <* [10] i32>( 15 | array 1 a32 <* [10] i32>(addrof a32 $arr2, dread i32 %i)), 16 | iread i32 <* [10] i32>( 17 | array 1 a32 <* [10] i32>(addrof a32 $arr3, dread i32 %i)) 18 | )) 19 | } 20 | return() 21 | } 22 | # EXEC: %irbuild Main.mpl 23 | # EXEC: %irbuild Main.irb.mpl 24 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 25 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0006-mapleall-irbuild-edge-arrayinit/Main.mpl: -------------------------------------------------------------------------------- 1 | var $iconst1 <[4] [4] i32> = [ [1007, 707, -273, 75], [0113, 0x4b, 75u, 75l], [75ul, 75lu, 31425926, 60223], [60223, 1619, 30, 314159]] 2 | 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]] 3 | func &printf (var %p1 <* i8>)void 4 | func &main ( ) i32 { 5 | call &printf (addrof a32 $fconst1) 6 | return (constval i32 0) } 7 | 8 | 9 | 10 | # EXEC: %irbuild Main.mpl 11 | # EXEC: %irbuild Main.irb.mpl 12 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 13 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0007-mapleall-irbuild-edge-attributes/Main.mpl: -------------------------------------------------------------------------------- 1 | var $i i32 align(4) = 987 2 | type $SS1 6 | var $iconst1 <[4] [4] i32> const = [ [1007, 707, -273, 75], [0113, 0x4b, 75u, 75l], [75ul, 75lu, 31425926, 60223], [60223, 1619, 30, 314159]] 7 | 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]] 8 | func &printf const static varargs (var %p1 <* i8 > volatile const, var %p2 <* i32> volatile)void 9 | func &noarg varargs ( ... ) void 10 | func $main static ( ) i32 { 11 | var %jj i32 volatile align(16) 12 | call &printf (addrof a32 $fconst1) 13 | return (constval i32 0) } 14 | 15 | 16 | 17 | # EXEC: %irbuild Main.mpl 18 | # EXEC: %irbuild Main.irb.mpl 19 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 20 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0008-mapleall-irbuild-edge-band/Main.mpl: -------------------------------------------------------------------------------- 1 | func $band32I ( 2 | var %i i32 3 | ) i32 { 4 | return ( 5 | band i32(dread i32 %i, 6 | constval i32 0x12))} 7 | func $band32I_2 ( 8 | var %i i32 9 | ) i32 { 10 | return ( 11 | band i32(dread i32 %i, 12 | constval i32 0x112))} 13 | func $band32RR ( 14 | var %i i32, var %j i32 15 | ) i32 { 16 | return ( 17 | band i32(dread i32 %i, 18 | dread i32 %j))} 19 | 20 | func $band64I ( 21 | var %i i64 22 | ) i64 { 23 | return ( 24 | band i64(dread i64 %i, 25 | constval i64 0x1200000015))} 26 | func $band64I_2 ( 27 | var %i i64 28 | ) i64 { 29 | return ( 30 | band i64(dread i64 %i, 31 | constval i64 0x1200000115))} 32 | func $band64RR ( 33 | var %i i64, 34 | var %j i64 35 | ) i64 { 36 | return ( 37 | band i64(dread i64 %i, 38 | dread i64 %j))} 39 | # EXEC: %irbuild Main.mpl 40 | # EXEC: %irbuild Main.irb.mpl 41 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 42 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0009-mapleall-irbuild-edge-binary/Main.mpl: -------------------------------------------------------------------------------- 1 | # a function returning (i + j) * -998 2 | func $foo ( 3 | # var %i xxx, 4 | var %i i32, var %j i32, var %k i32, 5 | var %i1 i32, var %j1 i32, var %k1 i32 6 | ) i32 { 7 | assertge (dread i32 %i, constval i32 0) 8 | assertlt (dread i32 %i, dread i32 %k) 9 | return ( 10 | ashr i32( 11 | mul i32 ( 12 | add i32 ( 13 | band i32 (dread i32 %i, dread i32 %j), 14 | bior i32 ( 15 | bxor i32(dread i32 %i1, dread i32 %k1), 16 | eq i32 i32 ( 17 | depositbits i32 1 23 ( 18 | land i32 (dread i32 %j1, dread i32 %k), 19 | lior i32 ( 20 | min i32 ( 21 | shl i32 (dread i32 %k1, dread i32 %j), 22 | sub i32 (dread i32 %j1, dread i32 %i)), 23 | rem i32 (dread i32 %i, dread i32 %k))), 24 | div i32( 25 | lshr i32 ( dread i32 %k, dread i32 %i), 26 | max i32 ( dread i32 %i, dread i32 %j))))), 27 | constval i32 -998), 28 | dread i32 %i))} 29 | 30 | # EXEC: %irbuild Main.mpl 31 | # EXEC: %irbuild Main.irb.mpl 32 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 33 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0010-mapleall-irbuild-edge-bior/Main.mpl: -------------------------------------------------------------------------------- 1 | func $bior32I ( 2 | var %i i32 3 | ) i32 { 4 | return ( 5 | bior i32(dread i32 %i, 6 | constval i32 0x12))} 7 | func $bior32I_2 ( 8 | var %i i32 9 | ) i32 { 10 | return ( 11 | bior i32(dread i32 %i, 12 | constval i32 0x112))} 13 | func $bior32RR ( 14 | var %i i32, var %j i32 15 | ) i32 { 16 | return ( 17 | bior i32(dread i32 %i, 18 | dread i32 %j))} 19 | 20 | func $bior64I ( 21 | var %i i64 22 | ) i64 { 23 | return ( 24 | bior i64(dread i64 %i, 25 | constval i64 0x1200000015))} 26 | func $bior64I_2 ( 27 | var %i i64 28 | ) i64 { 29 | return ( 30 | bior i64(dread i64 %i, 31 | constval i64 0x1200000115))} 32 | func $bior64RR ( 33 | var %i i64, 34 | var %j i64 35 | ) i64 { 36 | return ( 37 | bior i64(dread i64 %i, 38 | dread i64 %j))} 39 | # EXEC: %irbuild Main.mpl 40 | # EXEC: %irbuild Main.irb.mpl 41 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 42 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0011-mapleall-irbuild-edge-bnot/Main.mpl: -------------------------------------------------------------------------------- 1 | func $foo ( 2 | var %i i32 3 | #var %i1 i32, var %j1 i32, var %k1 i32 4 | ) i32 { 5 | return ( 6 | bnot i32(dread i32 %i))} 7 | 8 | func $foo1 ( 9 | var %i i32, var %j i32, var %k i32, 10 | var %i1 i32, var %j1 i32, var %k1 i32 11 | ) i32 { 12 | return ( 13 | bnot i32(dread i32 %i))} 14 | 15 | func $foo2 ( 16 | var %i i32, var %j i32, var %k i32 17 | ) i32 { 18 | return ( 19 | bnot i32(constval i32 0x111111111))} 20 | 21 | func $foo3 ( 22 | var %i i64, var %j i64, var %k i32 23 | ) i64 { 24 | return ( 25 | bnot i64(dread i64 %i))} 26 | 27 | 28 | func $foo5 ( 29 | var %i i64, var %j i64, var %k i32 30 | ) i64 { 31 | return ( 32 | bnot i64(constval i64 0x11111))} 33 | 34 | # todo float bnot 35 | # EXEC: %irbuild Main.mpl 36 | # EXEC: %irbuild Main.irb.mpl 37 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 38 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0012-mapleall-irbuild-edge-br/Main.mpl: -------------------------------------------------------------------------------- 1 | func $fact ( 2 | var %n i32) i32 { 3 | @fred2 4 | if (ne i32 i32 (dread i32 %n, constval i32 1)) { 5 | brfalse @fred2 (dread i32 %n) 6 | @fred1 7 | return (constval i32 0) } 8 | else { 9 | return (constval i32 1) } } 10 | # EXEC: %irbuild Main.mpl 11 | # EXEC: %irbuild Main.irb.mpl 12 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 13 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0013-mapleall-irbuild-edge-callassigned/Main.mpl: -------------------------------------------------------------------------------- 1 | func $singlefoo(var %a i32) i32 { 2 | return (dread i32 %a) 3 | } 4 | 5 | func $fact(var %n i32) i32 { 6 | var %m i32 7 | var %r1 i32 8 | var %r2 i32 9 | var %r3 i32 10 | callassigned &singlefoo(dread i32 %n) { 11 | dassign %m 0 12 | } 13 | # Not correct, but for parse and dump test. 14 | callassigned &singlefoo(dread i32 %n) { 15 | dassign %r1 1 16 | dassign %r2 2 17 | dassign %r3 3 18 | } 19 | return (dread i32 %n) 20 | } 21 | # EXEC: %irbuild Main.mpl 22 | # EXEC: %irbuild Main.irb.mpl 23 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 24 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0014-mapleall-irbuild-edge-ceil/Main.mpl: -------------------------------------------------------------------------------- 1 | func $ceilf64toi32 ( 2 | var %i f64 3 | ) i32 { 4 | return ( 5 | ceil i32 f64(dread f64 %i))} 6 | 7 | func $ceilf64toi64 ( 8 | var %i f64 9 | ) i64 { 10 | return ( 11 | ceil i64 f64(dread f64 %i))} 12 | 13 | func $ceilf32toi32 ( 14 | var %i f32 15 | ) i32 { 16 | return ( 17 | ceil i32 f32(dread f32 %i))} 18 | 19 | 20 | func $ceilf32toi64 ( 21 | var %i f32 22 | ) i64 { 23 | return ( 24 | ceil i64 f32(dread f32 %i))} 25 | 26 | # todo float ceil 27 | # EXEC: %irbuild Main.mpl 28 | # EXEC: %irbuild Main.irb.mpl 29 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 30 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0015-mapleall-irbuild-edge-ciorcand/Main.mpl: -------------------------------------------------------------------------------- 1 | flavor 1 2 | func &ciori32 ( 3 | var %i i32, var %j i32, var %k i32 4 | ) i32 { 5 | if (cior i32 ( cior i32(dread i32 %i, dread i32 %j), dread i32 %k)) { 6 | return (constval i32 1) 7 | } 8 | return ( 9 | cior i32(dread i32 %i, dread i32 %j))} 10 | 11 | func &candi64 ( 12 | var %i i64, var %j i64, var %k i64 13 | ) i32 { 14 | if (cand i32 (cand i32(dread i32 %i, dread i32 %j), dread i32 %k)) { 15 | return (constval i32 1) 16 | } 17 | return ( 18 | cand i64(dread i64 %i, dread i64 %j))} 19 | # EXEC: %irbuild Main.mpl 20 | # EXEC: %irbuild Main.irb.mpl 21 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 22 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0016-mapleall-irbuild-edge-classequal/Main.mpl: -------------------------------------------------------------------------------- 1 | type $RR 2 | type $SS {@f1 i32, @f2 i8, @f3 i8}> 3 | type $TT 4 | type $UU {@f1 i32, @f2 i8, @f3 i8}> 5 | func &foo ( var %x <$SS>) void { 6 | var %y <$UU> 7 | dassign %y 0 ( dread agg %x 0 ) 8 | return () } 9 | # EXEC: %irbuild Main.mpl 10 | # EXEC: %irbuild Main.irb.mpl 11 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 12 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0017-mapleall-irbuild-edge-class_type/Main.mpl: -------------------------------------------------------------------------------- 1 | type $RR 2 | type $SS {@f1 i32, @f2 i8, @f3 i8}> 3 | javaclass $TT <$SS> public static 4 | func &foo ( 5 | var %x <$SS>) i32 { 6 | dassign %x 2 ( constval i32 32 ) 7 | return ( dread i32 %x 2 ) } 8 | # EXEC: %irbuild Main.mpl 9 | # EXEC: %irbuild Main.irb.mpl 10 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 11 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0018-mapleall-irbuild-edge-constfloat/Main.mpl: -------------------------------------------------------------------------------- 1 | var $nan_f32 = nanf 2 | var $nan_f64 = nan 3 | var $inf_f32 = -inff 4 | var $inf_f64 = inf 5 | var $g_f32 = -1.2f 6 | var $g_f64 = 1.2 7 | func $add_f32 () f32 { 8 | return ( 9 | add f32(dread f32 $g_f32, constval f32 inff))} 10 | func $add_f64 () f64 { 11 | return ( 12 | add f64(dread f64 $g_f64, constval f64 -inf))} 13 | # EXEC: %irbuild Main.mpl 14 | # EXEC: %irbuild Main.irb.mpl 15 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 16 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0020-mapleall-irbuild-edge-cvtllutof32/Main.mpl: -------------------------------------------------------------------------------- 1 | func $cvtu64tof32 ( 2 | var %i u64 3 | ) f32 { 4 | return ( 5 | cvt f32 u64(dread u64 %i))} 6 | # EXEC: %irbuild Main.mpl 7 | # EXEC: %irbuild Main.irb.mpl 8 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 9 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0021-mapleall-irbuild-edge-cvtllutof64/Main.mpl: -------------------------------------------------------------------------------- 1 | func $cvtu64tof64 ( 2 | var %i u64 3 | ) f64 { 4 | return ( 5 | cvt f64 u64(dread u64 %i))} 6 | # EXEC: %irbuild Main.mpl 7 | # EXEC: %irbuild Main.irb.mpl 8 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 9 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0022-mapleall-irbuild-edge-depositbits1/Main.mpl: -------------------------------------------------------------------------------- 1 | func $foo ( 2 | var %i i32 3 | #var %i1 i32, var %j1 i32, var %k1 i32 4 | ) i32 { 5 | return ( 6 | depositbits i32 1 23( 7 | constval i32 0xfff, constval i32 0x11))} 8 | # EXEC: %irbuild Main.mpl 9 | # EXEC: %irbuild Main.irb.mpl 10 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 11 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0024-mapleall-irbuild-edge-dowhile/Main.mpl: -------------------------------------------------------------------------------- 1 | func $foo (var %i i32) i32 { 2 | dowhile { 3 | dassign %i ( 4 | mul i32 (dread i32 %i, dread i32 %i)) 5 | dassign %i ( 6 | add i32 (dread i32 %i, constval i32 1) )} ( 7 | lt i32 i32 ( dread i32 %i, constval i32 10) ) 8 | return ( constval i32 0 ) 9 | } 10 | # EXEC: %irbuild Main.mpl 11 | # EXEC: %irbuild Main.irb.mpl 12 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 13 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0025-mapleall-irbuild-edge-dupvardecl/Main.mpl: -------------------------------------------------------------------------------- 1 | var $g <*ptr> 2 | var $h <*ptr> = addrof ptr $g 3 | var $g <*ptr> = addrof ptr $h 4 | var $h <*ptr> 5 | # EXEC: %irbuild Main.mpl 6 | # EXEC: %irbuild Main.irb.mpl 7 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 8 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0026-mapleall-irbuild-edge-externfunc/Main.mpl: -------------------------------------------------------------------------------- 1 | func $foo ( var %i i32 ) i32 2 | func $fact ( var %n i32) i32 3 | func $fact ( var %n i32) i32 4 | func $foo ( var %i i32 ) i32 5 | 6 | func $fact ( 7 | var %n i32) i32 { 8 | if (ne i32 i32 (dread i32 %n, constval i32 1)) { 9 | call &foo( 10 | sub i32 (dread i32 %n, constval i32 1)) 11 | return (regread i32 %%retval)} 12 | else { 13 | return (constval i32 1) } } 14 | 15 | func $foo ( var %i i32 ) i32 { 16 | return (dread i32 %i) } 17 | # EXEC: %irbuild Main.mpl 18 | # EXEC: %irbuild Main.irb.mpl 19 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 20 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0027-mapleall-irbuild-edge-externvar/Main.mpl: -------------------------------------------------------------------------------- 1 | var $extern_var extern i32 public 2 | 3 | func $test_extern_var ( var %i i32 ) i32 { 4 | return (dread i32 $extern_var) } 5 | # EXEC: %irbuild Main.mpl 6 | # EXEC: %irbuild Main.irb.mpl 7 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 8 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0029-mapleall-irbuild-edge-fact/Main.mpl: -------------------------------------------------------------------------------- 1 | #int fact(int n) { 2 | # if (n == 1) 3 | # return 1; 4 | # return n * fact(n-1); 5 | #} 6 | 7 | func $fact (var %n i32) i32 { 8 | if (ne i32 i32 (dread i32 %n, constval i32 1)) { 9 | call &fact (sub i32 (dread i32 %n, constval i32 1)) 10 | return (mul i32 (dread i32 %n, regread i32 %%retval)) 11 | } 12 | return (constval i32 1) 13 | } 14 | 15 | # EXEC: %irbuild Main.mpl 16 | # EXEC: %irbuild Main.irb.mpl 17 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 18 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0030-mapleall-irbuild-edge-farray/Main.mpl: -------------------------------------------------------------------------------- 1 | # typedef struct { int f1, char f2, unsigned short f3[]} SS; 2 | # void foo(SS *x, SS *y) { 3 | # int i, j; 4 | # x->f3[ij] = y->f3[j]; 5 | # } 6 | 7 | type $SS }> 8 | func $foo ( var %x <*<$SS>>, var %y <*<$SS>>) void { 9 | var %i i32 10 | var %j i32 11 | iassign <* u16> ( array 1 ptr <*[]u16> ( 12 | iaddrof ptr <* <$SS>> 3 (dread ptr %x), dread i32 %i), 13 | iread u16 <* u16> ( array 1 ptr <*[]u16> ( 14 | iaddrof ptr <* <$SS>> 3 (dread ptr %y), dread i32 %j))) 15 | return() } 16 | # EXEC: %irbuild Main.mpl 17 | # EXEC: %irbuild Main.irb.mpl 18 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 19 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0031-mapleall-irbuild-edge-fileinfo/Main.mpl: -------------------------------------------------------------------------------- 1 | fileinfo{ 2 | @magic 345, 3 | @filename "adir/thisisafile.dex", 4 | @dexoffset 560, 5 | @flags 0x01ef, 6 | @linksize 100 7 | } 8 | type $SS 11 | var $sconst1 , 15 | @f33 i32, 16 | @accessflag 0x45e, 17 | @classdataoffset 118, 18 | @f44 i32, 19 | @f55 f32, 20 | @f66 f32, 21 | @superclassid 3333 22 | }> 23 | func $fact () i32 { 24 | funcinfo{ 25 | @funcname "afunc", 26 | @registers 345, 27 | @ins 560, 28 | @outs 444 29 | } 30 | return (dread i32 $sconst1 1) 31 | funcinfo{ 32 | @funcidx 345, 33 | @classidx 560 34 | } 35 | } 36 | # EXEC: %irbuild Main.mpl 37 | # EXEC: %irbuild Main.irb.mpl 38 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 39 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0032-mapleall-irbuild-edge-first/Main.mpl: -------------------------------------------------------------------------------- 1 | # a function returning (i + j) * -998 2 | func $foo ( 3 | # var %i xxx, 4 | var %i i32, 5 | var %j i32) i32 { 6 | return ( 7 | mul i32 ( 8 | add i32 ( dread i32 %i, dread i32 %j), 9 | constval i32 -998))} 10 | 11 | # EXEC: %irbuild Main.mpl 12 | # EXEC: %irbuild Main.irb.mpl 13 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 14 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0033-mapleall-irbuild-edge-floor/Main.mpl: -------------------------------------------------------------------------------- 1 | func $floorf64toi32 ( 2 | var %i f64 3 | ) i32 { 4 | return ( 5 | floor i32 f64(dread f64 %i))} 6 | 7 | func $floorf64toi64 ( 8 | var %i f64 9 | ) i64 { 10 | return ( 11 | floor i64 f64(dread f64 %i))} 12 | 13 | func $floorf32toi32 ( 14 | var %i f32 15 | ) i32 { 16 | return ( 17 | floor i32 f32(dread f32 %i))} 18 | 19 | 20 | func $floorf32toi64 ( 21 | var %i f32 22 | ) i64 { 23 | return ( 24 | floor i64 f32(dread f32 %i))} 25 | 26 | # todo float floor 27 | # EXEC: %irbuild Main.mpl 28 | # EXEC: %irbuild Main.irb.mpl 29 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 30 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0034-mapleall-irbuild-edge-foreachelem/Main.mpl: -------------------------------------------------------------------------------- 1 | var $arr1 <[10] f32> 2 | 3 | func $ArrayAdd () f32 { 4 | var %ff i32 5 | var %sum f32 6 | dassign %sum ( constval f32 0.0f ) 7 | foreachelem %ff $arr1 { 8 | dassign %sum ( add f32 ( dread f32 %sum, dread f32 %ff ) ) 9 | } 10 | return ( dread f32 %sum ) 11 | } 12 | # EXEC: %irbuild Main.mpl 13 | # EXEC: %irbuild Main.irb.mpl 14 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 15 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0035-mapleall-irbuild-edge-forwarddeclare/Main.mpl: -------------------------------------------------------------------------------- 1 | var $test_var i32 public 2 | 3 | func $test_extern_var ( var %i i32 ) i32 { 4 | return (dread i32 $test_var) 5 | } 6 | 7 | var $test_var i32 public = 0 8 | # EXEC: %irbuild Main.mpl 9 | # EXEC: %irbuild Main.irb.mpl 10 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 11 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0036-mapleall-irbuild-edge-funcptr/Main.mpl: -------------------------------------------------------------------------------- 1 | func $fact ( 2 | var %n i32) i32 { 3 | var %foo 4 | if (ne i32 i32 (dread i32 %n, constval i32 1)) { 5 | icall ( dread a64 %foo, 6 | sub i32 (dread i32 %n, constval i32 1)) 7 | return (regread i32 %%retval)} 8 | else { 9 | return (constval i32 1) } } 10 | # EXEC: %irbuild Main.mpl 11 | # EXEC: %irbuild Main.irb.mpl 12 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 13 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0037-mapleall-irbuild-edge-generics/Main.mpl: -------------------------------------------------------------------------------- 1 | type $ss1 , 2 | @x <* f32>}> 3 | type $ss2 , 4 | @x <* f32>}>, 5 | @pa <* }>>, 7 | @x1 <[10] f64>, 8 | @dx }> 9 | type $ss3 <[] > 10 | func &foo (var %x ) i32 { 11 | var %y 12 | dassign %y (dread agg %x) 13 | return (dread i32 %y 1) 14 | } 15 | var $g <$ss1{!T=i32}> 16 | var $h <$ss2{!U=i32,!SS=<$ss1{!T=f32}>}> 17 | func &bar () i32 { 18 | var %i i32 19 | callinstant &foo<{!W=<$ss2{!U=f32,!SS=i32}>}>( dread agg $g ) 20 | callinstantassigned &foo<{!W=<$ss1{!T=i32}>}>( dread agg $g ) { dassign %i 0 } 21 | virtualcallinstant &foo<{!W=<$ss2{!U=f32,!SS=i32}>}>( dread agg $g ) 22 | virtualcallinstantassigned &foo<{!W=<$ss1{!T=i32}>}>( dread agg $g ) { dassign %i 0 } 23 | superclasscallinstant &foo<{!W=<$ss2{!U=f32,!SS=i32}>}>( dread agg $g ) 24 | superclasscallinstantassigned &foo<{!W=<$ss1{!T=i32}>}>( dread agg $g ) { dassign %i 0 } 25 | interfacecallinstant &foo<{!W=<$ss2{!U=f32,!SS=i32}>}>( dread agg $g ) 26 | interfacecallinstantassigned &foo<{!W=<$ss1{!T=i32}>}>( dread agg $g ) { dassign %i 0 } 27 | return ( dread i32 %i ) 28 | } 29 | # EXEC: %irbuild Main.mpl 30 | # EXEC: %irbuild Main.irb.mpl 31 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 32 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0039-mapleall-irbuild-edge-hello/Main.mpl: -------------------------------------------------------------------------------- 1 | var $const1 <[13] i8> = [ 104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 10, 0 ] 2 | func $printf (var %p1 <* i8>)void 3 | func $main ( ) i32 { 4 | call &printf (addrof a32 $const1) 5 | return (constval i32 0) } 6 | 7 | 8 | 9 | # EXEC: %irbuild Main.mpl 10 | # EXEC: %irbuild Main.irb.mpl 11 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 12 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0040-mapleall-irbuild-edge-icallassigned/Main.mpl: -------------------------------------------------------------------------------- 1 | func $fact ( 2 | var %n i32) i32 { 3 | var %foo 4 | var %r1 i32 5 | var %r2 i32 6 | var %r3 i32 7 | if (ne i32 i32 (dread i32 %n, constval i32 1)) { 8 | icallassigned ( dread a64 %foo, 9 | sub i32 (dread i32 %n, constval i32 1)) { 10 | dassign %r1 0 11 | } 12 | # Not correct, but for parse and dump test. 13 | icallassigned ( dread a64 %foo, 14 | sub i32 (dread i32 %n, constval i32 1)) { 15 | dassign %r1 1 16 | dassign %r2 2 17 | dassign %r3 3 18 | } 19 | return (dread i32 %n) 20 | } 21 | } 22 | # EXEC: %irbuild Main.mpl 23 | # EXEC: %irbuild Main.irb.mpl 24 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 25 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0041-mapleall-irbuild-edge-if1/Main.mpl: -------------------------------------------------------------------------------- 1 | #int fact (int n) { 2 | # if(n != 1) 3 | # return foo(n - 1); 4 | # else return 1; 5 | #} 6 | 7 | func $fact ( 8 | var %n i32) i32 { 9 | if (ne i32 i32 (dread i32 %n, constval i32 1)) { 10 | return (constval i32 0) } } 11 | # EXEC: %irbuild Main.mpl 12 | # EXEC: %irbuild Main.irb.mpl 13 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 14 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0042-mapleall-irbuild-edge-if/Main.mpl: -------------------------------------------------------------------------------- 1 | #int fact (int n) { 2 | # if(n != 1) 3 | # return foo(n - 1); 4 | # else return 1; 5 | #} 6 | 7 | func $fact ( 8 | var %n i32) i32 { 9 | if (ne i32 i32 (dread i32 %n, constval i32 1)) { 10 | return (constval i32 0) } 11 | else { 12 | return (constval i32 1) } } 13 | # EXEC: %irbuild Main.mpl 14 | # EXEC: %irbuild Main.irb.mpl 15 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 16 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0043-mapleall-irbuild-edge-if_then_else/Main.mpl: -------------------------------------------------------------------------------- 1 | type $atyp <[10] f32> 2 | var $fff = 7789 3 | func $foo ( var %i i32 )i32 4 | 5 | func $fact ( 6 | var %n i32, var %m f32) i32 { 7 | type %i32ty 10 | var %alocal <%i32ty> 11 | dassign %alocal (constval i32 999) 12 | if (ne i32 i32 (dread i32 %n, constval i32 1)) { 13 | eval (dread i32 %n) 14 | call &foo( 15 | add i32 (dread i32 %n, constval i32 1)) 16 | return (regread i32 %%retval)} 17 | else { 18 | return (constval i32 1) } } 19 | # EXEC: %irbuild Main.mpl 20 | # EXEC: %irbuild Main.irb.mpl 21 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 22 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0044-mapleall-irbuild-edge-importpath/Main.mpl: -------------------------------------------------------------------------------- 1 | importpath "." 2 | importpath ".." 3 | importpath "../ff" 4 | var $x i32 5 | importpath "/a/bb/ccc/" 6 | func $foo (var %y i32) void { 7 | dassign $x (dread i32 %y) 8 | } 9 | # EXEC: %irbuild Main.mpl 10 | # EXEC: %irbuild Main.irb.mpl 11 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 12 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0045-mapleall-irbuild-edge-indirect/Main.mpl: -------------------------------------------------------------------------------- 1 | var $p <* i32> 2 | func $Foo (var %i i32) void { 3 | iassign <* i32>( 4 | dread a64 $p, 5 | add i32( 6 | iread i32 <* i32> ( dread a64 $p ), 7 | dread i32 %i)) 8 | return() 9 | } 10 | # EXEC: %irbuild Main.mpl 11 | # EXEC: %irbuild Main.irb.mpl 12 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 13 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0047-mapleall-irbuild-edge-interface/Main.mpl: -------------------------------------------------------------------------------- 1 | type $I1 2 | type $I2 3 | type $RR <$I2> {@e1 i32, &method1(agg)agg, &method2(void)void}> 4 | javainterface $UU <$RR> public static 5 | type $CC 6 | type $TT {@f1 i32, @f2 i8, @f3 i8, $I1, $I2, $RR}> 7 | # EXEC: %irbuild Main.mpl 8 | # EXEC: %irbuild Main.irb.mpl 9 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 10 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0048-mapleall-irbuild-edge-jarray/Main.mpl: -------------------------------------------------------------------------------- 1 | srclang 3 2 | type $SS }> 3 | func $foo ( var %x <*<$SS>>, var %y <*<$SS>>) void { 4 | var %i i32 5 | var %j i32 6 | iassign <* u16> ( array 1 ptr <*[]u16> ( 7 | iaddrof ptr <* <$SS>> 3 (dread ptr %x), dread i32 %i), 8 | iread u16 <* u16> ( array 1 ptr <*[]u16> ( 9 | iaddrof ptr <* <$SS>> 3 (dread ptr %y), dread i32 %j))) 10 | return() } 11 | # EXEC: %irbuild Main.mpl 12 | # EXEC: %irbuild Main.irb.mpl 13 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 14 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0049-mapleall-irbuild-edge-just_ret/Main.mpl: -------------------------------------------------------------------------------- 1 | type $atyp <[10] f32> 2 | var $fff = 7789 3 | func $foo ( var %i i32 )i32 4 | 5 | func $fact ( 6 | var %n i32, var %m f32) void { 7 | return () } 8 | # EXEC: %irbuild Main.mpl 9 | # EXEC: %irbuild Main.irb.mpl 10 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 11 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0050-mapleall-irbuild-edge-land/Main.mpl: -------------------------------------------------------------------------------- 1 | func $landi32 ( 2 | var %i i32, var %j i32 3 | ) i32 { 4 | return ( 5 | land i32(dread i32 %i, dread i32 %j))} 6 | 7 | func $landi64 ( 8 | var %i i64, var %j i64 9 | ) i32 { 10 | return ( 11 | land i64(dread i64 %i, dread i64 %j))} 12 | # EXEC: %irbuild Main.mpl 13 | # EXEC: %irbuild Main.irb.mpl 14 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 15 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0051-mapleall-irbuild-edge-lior/Main.mpl: -------------------------------------------------------------------------------- 1 | func $liori32 ( 2 | var %i i32, var %j i32 3 | ) i32 { 4 | return ( 5 | lior i32(dread i32 %i, dread i32 %j))} 6 | 7 | func $liori64 ( 8 | var %i i64, var %j i64 9 | ) i32 { 10 | return ( 11 | lior i64(dread i64 %i, dread i64 %j))} 12 | # EXEC: %irbuild Main.mpl 13 | # EXEC: %irbuild Main.irb.mpl 14 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 15 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0052-mapleall-irbuild-edge-lnot/Main.mpl: -------------------------------------------------------------------------------- 1 | func $foo ( 2 | var %i i32 3 | #var %i1 i32, var %j1 i32, var %k1 i32 4 | ) i32 { 5 | return ( 6 | lnot i32(dread i32 %i))} 7 | 8 | func $foo1 ( 9 | var %i i32, var %j i32, var %k i32, 10 | var %i1 i32, var %j1 i32, var %k1 i32 11 | ) i32 { 12 | return ( 13 | lnot i32(dread i32 %i))} 14 | 15 | func $foo2 ( 16 | var %i i32, var %j i32, var %k i32 17 | ) i32 { 18 | return ( 19 | lnot i32(constval i32 0x111111111))} 20 | 21 | func $foo3 ( 22 | var %i i64, var %j i64, var %k i32 23 | ) i64 { 24 | return ( 25 | lnot i64(dread i64 %i))} 26 | 27 | 28 | func $foo5 ( 29 | var %i i64, var %j i64, var %k i32 30 | ) i64 { 31 | return ( 32 | lnot i64(constval i64 0x11111))} 33 | 34 | # todo float lnot 35 | # EXEC: %irbuild Main.mpl 36 | # EXEC: %irbuild Main.irb.mpl 37 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 38 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0053-mapleall-irbuild-edge-loop/Main.mpl: -------------------------------------------------------------------------------- 1 | # float a[10]; 2 | # void init(void) { 3 | # int i; 4 | # for (i=0; i<10; i++) 5 | # a[i] = i*3; 6 | # } 7 | 8 | var $a <[10] f32> 9 | var $f1 f32 10 | func $init () void { 11 | var %i i32 12 | dassign %i ( constval i32 0 ) 13 | while ( 14 | lt i32 i32 ( dread i32 %i, constval i32 10) ) { 15 | iassign <* [10] f32> ( 16 | array 1 a32 <* [10] f32> (addrof a32 $a, dread i32 %i), 17 | mul f32 (dread f32 $f1, constval f32 3.33f) ) 18 | dassign %i ( 19 | add i32 (dread i32 %i, constval i32 1) )} } 20 | # EXEC: %irbuild Main.mpl 21 | # EXEC: %irbuild Main.irb.mpl 22 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 23 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0054-mapleall-irbuild-edge-malloc/Main.mpl: -------------------------------------------------------------------------------- 1 | func &foo ( var %i i32 ) void { 2 | var %p ptr 3 | dassign %p ( malloc ptr ( constval i32 8 )) 4 | dassign %p ( alloca ptr ( constval i32 16 )) 5 | dassign %p ( gcmalloc ref i32 ) 6 | dassign %p ( gcmallocjarray ref <[] i32> ( constval i32 5 )) 7 | free ( dread ref %p) 8 | } 9 | 10 | # EXEC: %irbuild Main.mpl 11 | # EXEC: %irbuild Main.irb.mpl 12 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 13 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0055-mapleall-irbuild-edge-methods2/Main.mpl: -------------------------------------------------------------------------------- 1 | type $RR 6 | type $SS { @accessflag 1234, 7 | &method1(agg)agg, 8 | &method2(void)void}> 9 | func $foo ( 10 | var %x <$SS>) i32 { 11 | dassign %x 2 ( constval i32 32 ) 12 | return ( dread i32 %x 2 ) } 13 | # EXEC: %irbuild Main.mpl 14 | # EXEC: %irbuild Main.irb.mpl 15 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 16 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0056-mapleall-irbuild-edge-methods/Main.mpl: -------------------------------------------------------------------------------- 1 | func &meth1() void 2 | func &meth3() i32 3 | var $sconst1 = [ 6=10.07f, 2=699, 3=-273, 4=75, 1=31425926, 5=6.02e+23f ] 12 | func &printf (var %p1 <* i8>)void 13 | func &main ( ) i32 { 14 | call &printf (addrof a32 $sconst1) 15 | return (constval i32 0) } 16 | 17 | 18 | 19 | # EXEC: %irbuild Main.mpl 20 | # EXEC: %irbuild Main.irb.mpl 21 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 22 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0057-mapleall-irbuild-edge-multiway/Main.mpl: -------------------------------------------------------------------------------- 1 | var $g i32 2 | var $h i32 3 | func $multiwayfunc ( var %n i32) i32 { 4 | multiway (dread i32 %n) @labdft { 5 | (add i32 (dread i32 $g, dread i32 $h)): goto @lab0 6 | (dread i32 $h): goto @lab1 7 | (constval i32 888): goto @lab0 8 | (constval i32 'Y'): goto @lab0 9 | (neg i32 (dread i32 $h)) : goto @lab9 } 10 | @lab0 11 | return (constval i32 -3) 12 | @labdft 13 | return (constval i32 100) 14 | @lab9 15 | return (constval i32 9) 16 | @lab1 17 | return (constval i32 1) } 18 | # EXEC: %irbuild Main.mpl 19 | # EXEC: %irbuild Main.irb.mpl 20 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 21 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0058-mapleall-irbuild-edge-multiwaystr/Main.mpl: -------------------------------------------------------------------------------- 1 | var $g ptr 2 | var $h i32 3 | func $multiwayfunc ( var %p ptr) ptr { 4 | multiway (dread ptr %p) @labdft { 5 | (dread ptr $g): goto @lab1 6 | (add ptr (dread i32 $g, dread i32 $h)): goto @lab0 7 | (conststr ptr "world"): goto @lab9 } 8 | @lab0 9 | return (dread ptr $g) 10 | @labdft 11 | return (conststr ptr "hello") 12 | @lab9 13 | return (add ptr (conststr ptr "foo", dread i32 $h)) 14 | @lab1 15 | return (addrof ptr $h) } 16 | # EXEC: %irbuild Main.mpl 17 | # EXEC: %irbuild Main.irb.mpl 18 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 19 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0059-mapleall-irbuild-edge-neg/Main.mpl: -------------------------------------------------------------------------------- 1 | func $foo ( 2 | var %i i32 3 | #var %i1 i32, var %j1 i32, var %k1 i32 4 | ) i32 { 5 | return ( 6 | neg i32(dread i32 %i))} 7 | 8 | func $foo1 ( 9 | var %i i32, var %j i32, var %k i32, 10 | var %i1 i32, var %j1 i32, var %k1 i32 11 | ) i32 { 12 | return ( 13 | neg i32(dread i32 %i))} 14 | 15 | func $foo2 ( 16 | var %i i32, var %j i32, var %k i32 17 | ) i32 { 18 | return ( 19 | neg i32(constval i32 0x111111111))} 20 | 21 | func $foo3 ( 22 | var %i i64, var %j i64, var %k i32 23 | ) i64 { 24 | return ( 25 | neg i64(dread i64 %i))} 26 | 27 | 28 | func $foo5 ( 29 | var %i i64, var %j i64, var %k i32 30 | ) i64 { 31 | return ( 32 | neg i64(constval i64 0x11111))} 33 | 34 | func $foo6 ( 35 | var %i f64 36 | ) f64 { 37 | return ( 38 | neg f64(dread f64 %i))} 39 | 40 | func $foo7 ( 41 | var %i f32 42 | ) f32 { 43 | return ( 44 | neg f32(dread f32 %i))} 45 | 46 | func $foo8 ( 47 | var %i f64 48 | ) f64 { 49 | return ( 50 | neg f64(constval f64 -1.24))} 51 | 52 | func $foo9 ( 53 | var %i f32 54 | ) f32 { 55 | return ( 56 | neg f32(constval f32 -1.24f))} 57 | # todo float neg 58 | # EXEC: %irbuild Main.mpl 59 | # EXEC: %irbuild Main.irb.mpl 60 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 61 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0060-mapleall-irbuild-edge-parentfields/Main.mpl: -------------------------------------------------------------------------------- 1 | type $RR 2 | type $SS {^f1 i32, @f2 i8, ^f3 i8}> 3 | javaclass $TT <$SS> public static 4 | func &foo ( 5 | var %x <$SS>) i32 { 6 | dassign %x -1 ( constval i32 32 ) 7 | return ( dread i32 %x -2 ) } 8 | # EXEC: %irbuild Main.mpl 9 | # EXEC: %irbuild Main.irb.mpl 10 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 11 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0061-mapleall-irbuild-edge-polymorphiccallassigned/Main.mpl: -------------------------------------------------------------------------------- 1 | type $SS 2 | javaclass $TT <$SS> public static 3 | 4 | func &bar (var %y i32) i32 { 5 | return (dread i32 %y) 6 | } 7 | 8 | func &foo (var %x <$SS>) i32 { 9 | var %ret i32 10 | polymorphiccallassigned &bar (dread i32 %x 1) {dassign %ret 0} 11 | return (dread i32 %ret) 12 | } 13 | # EXEC: %irbuild Main.mpl 14 | # EXEC: %irbuild Main.irb.mpl 15 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 16 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0062-mapleall-irbuild-edge-pregs/Main.mpl: -------------------------------------------------------------------------------- 1 | type $atyp <[10] f32> 2 | type $aaaa 3 | var $fff <$atyp> 4 | func $foo ( var %i i32 )i32 5 | 6 | func $fact ( 7 | var %n i32, var %m f32) i32 { 8 | regassign i32 %987 (constval i32 '0') 9 | if (ne i32 i32 (regread i32 %987, constval i32 10)) { 10 | eval (regread i32 %987) 11 | call &foo( 12 | sub i32 (regread i32 %1, constval i32 1)) 13 | return (regread i32 %%retval)} 14 | else { 15 | regassign i32 %987 (constval i32 111) 16 | return (constval i32 '1') } 17 | } 18 | # EXEC: %irbuild Main.mpl 19 | # EXEC: %irbuild Main.irb.mpl 20 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 21 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0063-mapleall-irbuild-edge-PrimTypes/Main.mpl: -------------------------------------------------------------------------------- 1 | var $myStruct < struct{ 2 | @number i32, 3 | @p <* i8> }> 4 | func $main ()i32{ 5 | #Character 6 | var %sChar i8 7 | var %usChar i8 8 | #signed and unsigned short integer 9 | var %shortInt i16 10 | var %shortInt2 i16 11 | var %sShortInt i16 12 | var %sShortInt2 i16 13 | var %usShortInt i16 14 | var %usShortInt2 i16 15 | #signed and unsigned integer 16 | var %int1 i32 17 | var %sInt i32 18 | var %usInt i32 19 | var %usInt2 i32 20 | #signed and unsigned long integer 21 | var %long1 i64 22 | var %long2 i64 23 | var %sLong1 i64 24 | var %sLong2 i64 25 | var %usLong i64 26 | var %usLong2 i64 27 | var %lLong1 i64 28 | var %iLong2 i64 29 | var %sLlong1 i64 30 | var %sLlonog2 i64 31 | var %usLlong i64 32 | var %usLlong2 i64 33 | #float 34 | var %Float f32 35 | #double 36 | var %Double f64 37 | #long double 38 | var %lDouble f64 39 | #Address 40 | var %array <[10] i8> 41 | iassign<* i8>( 42 | array 1 a64<*[10] i8>(addrof a64 %array, constval i64 1), 43 | constval i32 120)} 44 | # EXEC: %irbuild Main.mpl 45 | # EXEC: %irbuild Main.irb.mpl 46 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 47 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0064-mapleall-irbuild-edge-recip/Main.mpl: -------------------------------------------------------------------------------- 1 | func $foo6 ( 2 | var %i f64 3 | ) f64 { 4 | return ( 5 | recip f64(dread f64 %i))} 6 | 7 | func $foo7 ( 8 | var %i f32 9 | ) f32 { 10 | return ( 11 | recip f32(dread f32 %i))} 12 | 13 | func $foo8 ( 14 | var %i f64 15 | ) f64 { 16 | return ( 17 | recip f64(constval f64 -1.24))} 18 | 19 | func $foo9 ( 20 | var %i f32 21 | ) f32 { 22 | return ( 23 | recip f32(constval f32 -1.24f))} 24 | # todo float recip 25 | # EXEC: %irbuild Main.mpl 26 | # EXEC: %irbuild Main.irb.mpl 27 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 28 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0065-mapleall-irbuild-edge-retype/Main.mpl: -------------------------------------------------------------------------------- 1 | func $retypef64toi64 ( 2 | var %i f64 3 | ) i64 { 4 | return ( 5 | retype i64 (dread f64 %i))} 6 | 7 | func $retypei64tof64 ( 8 | var %i i64 9 | ) f64 { 10 | return ( 11 | retype f64 (dread i64 %i))} 12 | 13 | func $retypef32toi32 ( 14 | var %i f32 15 | ) i32 { 16 | return ( 17 | retype i32 (dread f32 %i))} 18 | 19 | func $retypei32tof32 ( 20 | var %i i32 21 | ) f32 { 22 | return ( 23 | retype f32 (dread i32 %i))} 24 | # EXEC: %irbuild Main.mpl 25 | # EXEC: %irbuild Main.irb.mpl 26 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 27 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0066-mapleall-irbuild-edge-select/Main.mpl: -------------------------------------------------------------------------------- 1 | func $selecti32 ( 2 | var %i i32, 3 | var %j i32, 4 | var %k i32) i32 { 5 | return ( 6 | select i32 ( 7 | dread i32 %i, 8 | dread i32 %j, 9 | dread i32 %k))} 10 | 11 | func $selecti64 ( 12 | var %i i32, 13 | var %j i64, 14 | var %k i64) i64 { 15 | return ( 16 | select i64 ( 17 | dread i32 %i, 18 | dread i64 %j, 19 | dread i64 %k))} 20 | 21 | func $selectf32 ( 22 | var %i i32, 23 | var %j f32, 24 | var %k f32) f32 { 25 | return ( 26 | select f32 ( 27 | dread i32 %i, 28 | dread f32 %j, 29 | dread f32 %k))} 30 | 31 | func $selectf64 ( 32 | var %i i32, 33 | var %j f64, 34 | var %k f64) f64 { 35 | return ( 36 | select f64 ( 37 | dread i32 %i, 38 | dread f64 %j, 39 | dread f64 %k))} 40 | # EXEC: %irbuild Main.mpl 41 | # EXEC: %irbuild Main.irb.mpl 42 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 43 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0067-mapleall-irbuild-edge-specialchar/Main.mpl: -------------------------------------------------------------------------------- 1 | # ;, / and | are allowed name characters, but they cannot be the starting char 2 | func $foo ( 3 | var %i; i32, 4 | var %j|/ i32 5 | ) i32 { 6 | return ( 7 | add i32(dread i32 %i;, dread i32 %j|/))} 8 | # EXEC: %irbuild Main.mpl 9 | # EXEC: %irbuild Main.irb.mpl 10 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 11 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0068-mapleall-irbuild-edge-sqrt/Main.mpl: -------------------------------------------------------------------------------- 1 | func $foo6 ( 2 | var %i f64 3 | ) f64 { 4 | return ( 5 | sqrt f64(dread f64 %i))} 6 | 7 | func $foo7 ( 8 | var %i f32 9 | ) f32 { 10 | return ( 11 | sqrt f32(dread f32 %i))} 12 | 13 | func $foo8 ( 14 | var %i f64 15 | ) f64 { 16 | return ( 17 | sqrt f64(constval f64 4.0))} 18 | 19 | func $foo9 ( 20 | var %i f32 21 | ) f32 { 22 | return ( 23 | sqrt f32(constval f32 4.0f))} 24 | # todo float sqrt 25 | # EXEC: %irbuild Main.mpl 26 | # EXEC: %irbuild Main.irb.mpl 27 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 28 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0069-mapleall-irbuild-edge-struct2/Main.mpl: -------------------------------------------------------------------------------- 1 | type $SS 4 | var $sconst1 , 7 | @f33 i32, 8 | @f44 i32, 9 | @f55 f32, 10 | @f66 f32}> = [ 1=1007, 2= [1=11.11f, 2=22.22f], 5=-273, 6=75, 4=6023.1f ] 11 | func $fact () i32 { 12 | return (dread i32 $sconst1 1) 13 | } 14 | # EXEC: %irbuild Main.mpl 15 | # EXEC: %irbuild Main.irb.mpl 16 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 17 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0070-mapleall-irbuild-edge-structarrayinit/Main.mpl: -------------------------------------------------------------------------------- 1 | type $__field_meta__ , 5 | @type <* void>}> 6 | var $v1 <* void> public 7 | var $v2 <* void> public 8 | var $vs <[1] <$__field_meta__>> public = [[1= 0x35ad1b, 2= 0xabcd, 3= addrof ptr $v2, 4= addrof ptr $v1]] 9 | var $vvs <[2][1] <$__field_meta__>> public = [[[1= 11, 2= 22, 3= addrof ptr $v1, 4= addrof ptr $v1]], 10 | [[1= 33, 2= 44, 3= addrof ptr $v2, 4= addrof ptr $v2]]] 11 | # EXEC: %irbuild Main.mpl 12 | # EXEC: %irbuild Main.irb.mpl 13 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 14 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0071-mapleall-irbuild-edge-structinit/Main.mpl: -------------------------------------------------------------------------------- 1 | var $sconst1 = [ 6=10.07f, 2=699, 3=-273, 4=75, 1=31425926, 5=6.02e+23f ] 8 | func &printf (var %p1 <* i8>)void 9 | func &main ( ) i32 { 10 | call &printf (addrof a32 $sconst1) 11 | return (constval i32 0) } 12 | 13 | 14 | 15 | # EXEC: %irbuild Main.mpl 16 | # EXEC: %irbuild Main.irb.mpl 17 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 18 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0072-mapleall-irbuild-edge-struct/Main.mpl: -------------------------------------------------------------------------------- 1 | # typedef struct ss { 2 | # int f1; 3 | # char f2:3; 4 | # char f3:5; 5 | # } SS; 6 | # SS foo(SS x) { 7 | # x.f2 = 32; 8 | # return x; 9 | # } 10 | type $SS 11 | func $foo ( 12 | var %x <$SS>) i32 { 13 | dassign %x 2 ( constval i32 32 ) 14 | return ( dread i32 %x 2 ) } 15 | # EXEC: %irbuild Main.mpl 16 | # EXEC: %irbuild Main.irb.mpl 17 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 18 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0075-mapleall-irbuild-edge-substructinit/Main.mpl: -------------------------------------------------------------------------------- 1 | type $SS 4 | var $sconst1 , 7 | @f33 i32, 8 | @f44 i32, 9 | @f55 f32, 10 | @f66 f32}> = [ 6=1007, 2= [1=11.11f, 2=22.22f], 3=-273.2f, 4=75.3f, 1=1425926, 5=6023 ] 11 | func $printf (var %p1 <* i8>)void 12 | func $main ( ) i32 { 13 | call &printf (addrof a32 $sconst1) 14 | return (constval i32 0) } 15 | 16 | 17 | 18 | # EXEC: %irbuild Main.mpl 19 | # EXEC: %irbuild Main.irb.mpl 20 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 21 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0076-mapleall-irbuild-edge-switch/Main.mpl: -------------------------------------------------------------------------------- 1 | func $switchfunc ( var %n i32) i32 { 2 | var %alocal i32 3 | switch (dread i32 %n) @labdft { 4 | -3: goto @lab0 5 | 1: goto @lab1 6 | 9: goto @lab9 } 7 | @lab0 8 | return (constval i32 -3) 9 | @labdft 10 | return (constval i32 100) 11 | @lab9 12 | return (constval i32 9) 13 | @lab1 14 | return (constval i32 1) } 15 | # EXEC: %irbuild Main.mpl 16 | # EXEC: %irbuild Main.irb.mpl 17 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 18 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0077-mapleall-irbuild-edge-sync/Main.mpl: -------------------------------------------------------------------------------- 1 | # 1 public class sync { 2 | # 2 private Object go = new Object(); 3 | # 3 private int waiters = 0; 4 | # 4 5 | # 5 public void foo() { 6 | # 6 synchronized (go) { 7 | # 7 waiters++; 8 | # 8 } 9 | # 9 } 10 | # 10 } 11 | 12 | # some unrelated functions are removed 13 | type $Ljava/lang/Object; 14 | type $Lsync; { 15 | @go <* <$Ljava/lang/Object;>> private, 16 | @waiters i32 private, 17 | &Lsync;|foo|__V|(<* <$Lsync;>>) void}> 18 | func &Lsync;|foo|__V| (var %_this <* <$Lsync;>>) void { 19 | var %Reg1_R33 <* <$Ljava/lang/Object;>> 20 | var %Reg0_I i32 21 | var %Reg0_R38 <* void> 22 | #LINE sync.java:6 23 | dassign %Reg1_R33 0 (iread ptr <* <$Lsync;>> 1 (dread ptr %_this 0)) 24 | syncenter (dread ptr %Reg1_R33 0) 25 | #LINE sync.java:7 26 | dassign %Reg0_I 0 (iread i32 <* <$Lsync;>> 2 (dread ptr %_this 0)) 27 | dassign %Reg0_I 0 (add i32 ( 28 | dread i32 %Reg0_I 0, 29 | cvt i32 i8 (constval i8 1))) 30 | iassign <* <$Lsync;>> 2 (dread ptr %_this 0, dread i32 %Reg0_I 0) 31 | #LINE sync.java:8 32 | syncexit (dread ptr %Reg1_R33 0) 33 | #LINE sync.java:9 34 | return () 35 | #LINE sync.java:8 36 | dassign %Reg0_R38 0 (regread ptr %%thrownval) 37 | syncexit (dread ptr %Reg1_R33 0) 38 | throw (dread ptr %Reg0_R38 0) 39 | } 40 | # EXEC: %irbuild Main.mpl 41 | # EXEC: %irbuild Main.irb.mpl 42 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 43 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0078-mapleall-irbuild-edge-ternary/Main.mpl: -------------------------------------------------------------------------------- 1 | # a function returning (i + j) * -998 2 | func $foo ( 3 | # var %i xxx, 4 | var %i i32, 5 | var %j i32, 6 | var %k i32) i32 { 7 | return ( 8 | select i32 ( 9 | dread i32 %i, 10 | dread i32 %j, 11 | dread i32 %k))} 12 | 13 | # EXEC: %irbuild Main.mpl 14 | # EXEC: %irbuild Main.irb.mpl 15 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 16 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0079-mapleall-irbuild-edge-testconst/Main.mpl: -------------------------------------------------------------------------------- 1 | #var $const1 <[13] i8> [ 104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 10, 0 ] 2 | 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 ] 3 | func $printf (var %p1 <* i8>)void 4 | func $main ( ) i32 { 5 | call &printf (addrof a32 $fconst1) 6 | call &printf (conststr ptr "\"hello maple\"", conststr a32 "\nworld\n") 7 | # 你好: E4 BD A0 E5 A5 BD 中国: E4 B8 AD E5 9B BD 8 | call &printf (conststr16 ptr "\xE4\xBD\xA0\xE5\xA5\xBD", conststr16 a32 "\xE4\xB8\xAD\xE5\x9B\xBD") 9 | return (constval i32 0) } 10 | 11 | 12 | 13 | # EXEC: %irbuild Main.mpl 14 | # EXEC: %irbuild Main.irb.mpl 15 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 16 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0082-mapleall-irbuild-edge-twofunc/Main.mpl: -------------------------------------------------------------------------------- 1 | #int fact (int n) { 2 | # if(n != 1) 3 | # return foo(n - 1); 4 | # else return 1; 5 | #} 6 | func $foo varargs ( var %i i32, ... ) i32 { 7 | return (dread i32 %i) } 8 | func $foo1 varargs ( ... ) i32 { 9 | return (constval i32 99) } 10 | 11 | func $fact ( 12 | var %n i32) i32 { 13 | if (ne i32 i32 (dread i32 %n, constval i32 1)) { 14 | call &foo( 15 | sub i32 (dread i32 %n, constval i32 1)) 16 | return (regread i32 %%retval)} 17 | else { 18 | return (constval i32 1) } } 19 | # EXEC: %irbuild Main.mpl 20 | # EXEC: %irbuild Main.irb.mpl 21 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 22 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0083-mapleall-irbuild-edge-tyconvertion/Main.mpl: -------------------------------------------------------------------------------- 1 | # a function returning unary(i + j) * -998 2 | #type $SS 3 | func $foo ( 4 | var %k , 5 | var %f f32, 6 | var %i i32, 7 | var %j i32)i64 { 8 | return ( 9 | cvt i64 i32 (constval i32 12345))} 10 | 11 | # EXEC: %irbuild Main.mpl 12 | # EXEC: %irbuild Main.irb.mpl 13 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 14 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0084-mapleall-irbuild-edge-unary/Main.mpl: -------------------------------------------------------------------------------- 1 | # a function returning unary(i + j) * -998 2 | func $foo ( 3 | var %i i32, 4 | var %j i32) f32 { 5 | return ( 6 | recip f32( 7 | sqrt f32( 8 | cvt f32 i32( 9 | mul i32 ( 10 | extractbits i32 1 23 ( add i32 ( bnot i32 (dread i32 %i), lnot i32 (dread i32 %j))), 11 | neg i32 ( constval i32 -998))))))} 12 | 13 | # EXEC: %irbuild Main.mpl 14 | # EXEC: %irbuild Main.irb.mpl 15 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 16 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0085-mapleall-irbuild-edge-virtualcallassigned/Main.mpl: -------------------------------------------------------------------------------- 1 | type $RR 2 | type $SS { &method1(agg)agg, 3 | &method2(void)void}> 4 | func $foo ( 5 | var %x <$SS>) i32 { 6 | var %r1 i32 7 | var %r2 i32 8 | var %r3 i32 9 | dassign %x 2 ( constval i32 32 ) 10 | # Not correct, but for parse and dump test. 11 | virtualcallassigned &method2(addrof ptr %x) { 12 | dassign %r1 1 13 | dassign %r2 2 14 | dassign %r3 3 15 | } 16 | superclasscallassigned &method2(addrof ptr %x) { 17 | dassign %r1 1 18 | dassign %r2 2 19 | dassign %r3 3 20 | } 21 | interfacecallassigned &method2(addrof ptr %x) { 22 | dassign %r1 1 23 | dassign %r2 2 24 | dassign %r3 3 25 | } 26 | return ( dread i32 %x 2 ) } 27 | # EXEC: %irbuild Main.mpl 28 | # EXEC: %irbuild Main.irb.mpl 29 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 30 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0086-mapleall-irbuild-edge-virtualcall/Main.mpl: -------------------------------------------------------------------------------- 1 | type $RR 2 | type $SS { &method1(agg)agg, 3 | &method2(void)void}> 4 | func $foo ( 5 | var %x <$SS>) i32 { 6 | dassign %x 2 ( constval i32 32 ) 7 | virtualcall &method2(addrof ptr %x) 8 | superclasscall &method2(addrof ptr %x) 9 | interfacecall &method2(addrof ptr %x) 10 | return ( dread i32 %x 2 ) } 11 | # EXEC: %irbuild Main.mpl 12 | # EXEC: %irbuild Main.irb.mpl 13 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 14 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/I0087-mapleall-irbuild-edge-while/Main.mpl: -------------------------------------------------------------------------------- 1 | # int foo(void) { 2 | # int n = 1; 3 | # int i; 4 | # for (i=1; i<10; i++) 5 | # n = n * i; 6 | # } 7 | 8 | func $foo (var %i i32) i32 { 9 | while ( 10 | lt i32 i32 ( dread i32 %i, constval i32 10) ) { 11 | dassign %i ( 12 | mul i32 (dread i32 %i, dread i32 %i)) 13 | dassign %i ( 14 | add i32 (dread i32 %i, constval i32 1) )} 15 | return ( constval i32 1 ) 16 | } 17 | # EXEC: %irbuild Main.mpl 18 | # EXEC: %irbuild Main.irb.mpl 19 | # EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl 20 | -------------------------------------------------------------------------------- /test/testsuite/irbuild_test/test.cfg: -------------------------------------------------------------------------------- 1 | [suffix] 2 | mpl = # 3 | 4 | [internal-var] 5 | irbuild = ${MAPLE_ROOT}/output/bin/irbuild 6 | cmp = /usr/bin/cmp -s 7 | 8 | [description] 9 | title = Maple Irbuild Test 10 | 11 | -------------------------------------------------------------------------------- /test/testsuite/ouroboros/eh_test/RT0023-rt-eh-NativeCatchExceptionTest/jniNativeCatchExceptionTest.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #include 16 | #include 17 | 18 | extern "C" { 19 | JNIEXPORT void JNICALL Java_NativeCatchExceptionTest_nativeNativeCatchExceptionTest__ 20 | (JNIEnv *env, jobject j_obj) 21 | { 22 | jclass cls = NULL; 23 | jmethodID mid = NULL; 24 | 25 | cls = env->GetObjectClass(j_obj); 26 | if ( cls == NULL ) { 27 | return; 28 | } 29 | 30 | mid = env->GetMethodID(cls, "callback", "()V"); 31 | if ( mid == NULL ) { 32 | return; 33 | } 34 | 35 | env->CallVoidMethod(j_obj, mid); 36 | printf("------>CheckPoint:CcanContinue\n"); 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /test/testsuite/ouroboros/eh_test/RT0024-rt-eh-NativeCodeCheckExceptionTest/jniNativeCodeCheckExceptionTest.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #include 16 | #include 17 | 18 | extern "C" { 19 | JNIEXPORT void JNICALL Java_NativeCodeCheckExceptionTest_nativeNativeCodeCheckExceptionTest__ 20 | (JNIEnv *env, jobject j_obj) 21 | { 22 | jclass cls = NULL; 23 | jmethodID mid = NULL; 24 | 25 | cls = env->GetObjectClass(j_obj); 26 | if (cls == NULL){ 27 | return; 28 | } 29 | mid = env->GetMethodID(cls,"callback", "()V"); 30 | if (mid == NULL){ 31 | return; 32 | } 33 | 34 | env->CallVoidMethod(j_obj, mid); 35 | 36 | jthrowable j_exc = NULL; 37 | j_exc = env->ExceptionOccurred(); 38 | 39 | if(j_exc){ 40 | env->Throw(j_exc); 41 | } 42 | 43 | printf("------>CheckPoint:CcanContinue\n"); 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /test/testsuite/ouroboros/eh_test/RT0025-rt-eh-NativeNewExceptionTest/jniNativeNewExceptionTest.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #include 16 | #include 17 | 18 | extern "C" { 19 | JNIEXPORT void JNICALL Java_NativeNewExceptionTest_nativeNativeNewExceptionTest__ 20 | (JNIEnv *env, jobject j_obj) 21 | { 22 | jclass cls = NULL; 23 | jmethodID mid = NULL; 24 | 25 | cls = env->GetObjectClass(j_obj); 26 | if (cls == NULL){ 27 | return; 28 | } 29 | mid = env->GetMethodID(cls,"callback", "()V"); 30 | if (mid == NULL){ 31 | return; 32 | } 33 | 34 | env->CallVoidMethod(j_obj, mid); 35 | jclass newExcCls = NULL; 36 | newExcCls = env->FindClass("java/lang/StringIndexOutOfBoundsException"); 37 | if (newExcCls == NULL){ 38 | return; 39 | } 40 | 41 | env->ThrowNew(newExcCls,"NativeThrowNew"); 42 | printf("------>CheckPoint:CcanContinue\n"); 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /test/testsuite/ouroboros/eh_test/RT0026-rt-eh-NativeTryCatchNewExceptionTest/jniNativeTryCatchNewExceptionTest.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #include 16 | #include 17 | 18 | extern "C" { 19 | JNIEXPORT void JNICALL Java_NativeTryCatchNewExceptionTest_nativeNativeTryCatchNewExceptionTest__ 20 | (JNIEnv *env, jobject j_obj) 21 | { 22 | jclass cls = NULL; 23 | jmethodID mid = NULL; 24 | 25 | cls = env->GetObjectClass(j_obj); 26 | if (cls == NULL){ 27 | return; 28 | } 29 | mid = env->GetMethodID(cls,"callback", "()V"); 30 | if (mid == NULL){ 31 | return; 32 | } 33 | 34 | env->CallVoidMethod(j_obj, mid); 35 | 36 | jclass newExcCls = NULL; 37 | newExcCls = env->FindClass("java/lang/StringIndexOutOfBoundsException"); 38 | if (newExcCls == NULL){ 39 | return; 40 | } 41 | 42 | env->ThrowNew(newExcCls,"NativeThrowNew"); 43 | 44 | printf("------>CheckPoint:CcanContinue\n"); 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /test/testsuite/ouroboros/eh_test/RT0030-rt-eh-NativeCheckFatalErrorExceptionTest/jniNativeCheckFatalErrorExceptionTest.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | #include 16 | #include 17 | 18 | extern "C" { 19 | JNIEXPORT void JNICALL Java_NativeCheckFatalErrorExceptionTest_nativeNativeCheckFatalErrorExceptionTest__ 20 | (JNIEnv *env, jobject j_obj) 21 | { 22 | jclass cls = NULL; 23 | jmethodID mid = NULL; 24 | 25 | cls = env->GetObjectClass(j_obj); 26 | if (cls == NULL){ 27 | return; 28 | } 29 | mid = env->GetMethodID(cls,"callback", "()V"); 30 | if (mid == NULL){ 31 | return; 32 | } 33 | 34 | env->CallVoidMethod(j_obj, mid); 35 | env->FatalError("------>CheckPoint:FatalError"); 36 | 37 | printf("------>CheckPoint:CcanContinue\n"); 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /test/testsuite/ouroboros/reflection_test/RT0200-rt-reflection-AnnotationTypeParameterSetTest/AnnoA.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | import java.lang.annotation.*; 16 | 17 | @Target(ElementType.TYPE_PARAMETER) 18 | @Retention(RetentionPolicy.RUNTIME) 19 | @Documented 20 | @Inherited 21 | public @interface AnnoA { 22 | int intA(); 23 | byte byteA(); 24 | char charA(); 25 | double doubleA(); 26 | boolean booleanA(); 27 | long longA(); 28 | float floatA(); 29 | short shortA(); 30 | int[] intAA(); 31 | byte[] byteAA(); 32 | char[] charAA(); 33 | double[] doubleAA(); 34 | boolean[] booleanAA(); 35 | long[] longAA(); 36 | float[] floatAA(); 37 | short[] shortAA(); 38 | String stringA(); 39 | String[] stringAA(); 40 | Class classA(); 41 | Class[] classAA(); 42 | Thread.State stateA(); 43 | Thread.State[] stateAA(); 44 | AnnoB annoBA(); 45 | AnnoB[] annoBAA(); 46 | } 47 | -------------------------------------------------------------------------------- /test/testsuite/ouroboros/reflection_test/RT0200-rt-reflection-AnnotationTypeParameterSetTest/AnnoB.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | import java.lang.annotation.*; 16 | 17 | @Target(ElementType.TYPE) 18 | @Retention(RetentionPolicy.RUNTIME) 19 | @Documented 20 | @Inherited 21 | public @interface AnnoB { 22 | int intB() default 999; 23 | } 24 | -------------------------------------------------------------------------------- /test/testsuite/ouroboros/reflection_test/RT0201-rt-reflection-AnnotationTypeUseSetTest/AnnoA.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | import java.lang.annotation.*; 16 | 17 | @Target(ElementType.TYPE_USE) 18 | @Retention(RetentionPolicy.RUNTIME) 19 | @Documented 20 | @Inherited 21 | public @interface AnnoA { 22 | int intA(); 23 | byte byteA(); 24 | char charA(); 25 | double doubleA(); 26 | boolean booleanA(); 27 | long longA(); 28 | float floatA(); 29 | short shortA(); 30 | int[] intAA(); 31 | byte[] byteAA(); 32 | char[] charAA(); 33 | double[] doubleAA(); 34 | boolean[] booleanAA(); 35 | long[] longAA(); 36 | float[] floatAA(); 37 | short[] shortAA(); 38 | String stringA(); 39 | String[] stringAA(); 40 | Class classA(); 41 | Class[] classAA(); 42 | Thread.State stateA(); 43 | Thread.State[] stateAA(); 44 | AnnoB annoBA(); 45 | AnnoB[] annoBAA(); 46 | } 47 | -------------------------------------------------------------------------------- /test/testsuite/ouroboros/reflection_test/RT0201-rt-reflection-AnnotationTypeUseSetTest/AnnoB.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | import java.lang.annotation.*; 16 | 17 | @Target(ElementType.TYPE) 18 | @Retention(RetentionPolicy.RUNTIME) 19 | @Documented 20 | @Inherited 21 | public @interface AnnoB { 22 | int intB() default 999; 23 | } 24 | -------------------------------------------------------------------------------- /test/testsuite/ouroboros/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/AnnoA.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | import java.lang.annotation.*; 16 | 17 | @Target(ElementType.TYPE) 18 | @Retention(RetentionPolicy.RUNTIME) 19 | @Documented 20 | @Inherited 21 | public @interface AnnoA { 22 | int intA() default Integer.MAX_VALUE; 23 | 24 | double doubleA() default Double.MIN_VALUE; 25 | 26 | String stringA() default ""; 27 | 28 | AnnoB annoBA(); 29 | 30 | ENUMA enumA() default ENUMA.A; 31 | } 32 | -------------------------------------------------------------------------------- /test/testsuite/ouroboros/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/AnnoB.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | import java.lang.annotation.*; 16 | 17 | @Target(ElementType.TYPE) 18 | @Retention(RetentionPolicy.RUNTIME) 19 | @Documented 20 | @Inherited 21 | public @interface AnnoB { 22 | int intB() default 999; 23 | } 24 | -------------------------------------------------------------------------------- /test/testsuite/ouroboros/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/AnnoC.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | import java.lang.annotation.*; 16 | 17 | @Target(ElementType.TYPE) 18 | @Retention(RetentionPolicy.RUNTIME) 19 | @Documented 20 | @Inherited 21 | public @interface AnnoC { 22 | int[] intA() default Integer.MAX_VALUE; 23 | 24 | double[] doubleA() default Double.MIN_VALUE; 25 | 26 | String[] stringA() default ""; 27 | 28 | AnnoB[] annoBA() default @AnnoB; 29 | 30 | ENUMA[] enumA() default ENUMA.A; 31 | } 32 | -------------------------------------------------------------------------------- /test/testsuite/ouroboros/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/AnnoD.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | import java.lang.annotation.*; 16 | 17 | @Target(ElementType.TYPE) 18 | @Retention(RetentionPolicy.RUNTIME) 19 | @Documented 20 | @Inherited 21 | public @interface AnnoD { 22 | int intA() default Integer.MAX_VALUE; 23 | 24 | double doubleA() default Double.MIN_VALUE; 25 | 26 | String stringA() default ""; 27 | 28 | AnnoB annoBA(); 29 | 30 | ENUMA enumA() default ENUMA.A; 31 | } 32 | -------------------------------------------------------------------------------- /test/testsuite/ouroboros/reflection_test/RT0202-rt-reflection-AnnotationMultiThread/ENUMA.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | */ 15 | public enum ENUMA { 16 | A, 17 | B, 18 | C 19 | } 20 | -------------------------------------------------------------------------------- /test/testsuite/ouroboros/test.cfg: -------------------------------------------------------------------------------- 1 | [suffix] 2 | java = // 3 | 4 | [internal-var] 5 | maple = python3 ${MAPLE_ROOT}/test/testsuite/maple.py 6 | run = # 7 | build_option = --javac="-bootclasspath ${MAPLE_ROOT}/libjava-core/java-core.jar" --maple="-O0 --mplt=${MAPLE_ROOT}/libjava-core/java-core.mplt --option=\"-use-string-factory::: \"" -s maple 8 | run_option = 9 | 10 | [description] 11 | title = Maple Ouroboros Test 12 | 13 | -------------------------------------------------------------------------------- /test/testsuite/ouroboros/testlist: -------------------------------------------------------------------------------- 1 | [ALL-TEST-CASE] 2 | arrayboundary_test 3 | clinit_test 4 | eh_test 5 | fuzzapi_test 6 | other_test 7 | parent_test 8 | reflection_test 9 | stmtpre_test 10 | string_test 11 | subsumeRC_test 12 | thread_test 13 | unsafe_test 14 | memory_management 15 | 16 | [EXCLUDE-TEST-CASE] 17 | memory_management/Annotation 18 | reflection_test/issue-0000-rt-Reflection-ReflectionforName2 19 | reflection_test/RT0202-rt-reflection-AnnotationMultiThread 20 | thread_test/RT0180-rt-thread-MonitorTestCase8 21 | memory_management/MemoryTest/RC0410-rc-Memory-stressTestCase29 22 | 23 | -------------------------------------------------------------------------------- /test/testsuite/ouroboros/thread_test/RT0120-rt-thread-ThreadTest3/ThreadTest.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. 3 | * 4 | * OpenArkCompiler is licensed under the Mulan PSL v1. 5 | * You can use this software according to the terms and conditions of the Mulan PSL v1. 6 | * You may obtain a copy of Mulan PSL v1 at: 7 | * 8 | * http://license.coscl.org.cn/MulanPSL 9 | * 10 | * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER 11 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR 12 | * FIT FOR A PARTICULAR PURPOSE. 13 | * See the Mulan PSL v1 for more details. 14 | * -@TestCaseID: ThreadTest 15 | *- @TestCaseName: Thread_ThreadTest.java 16 | *- @RequirementName: Java Thread 17 | *- @Title/Destination: Test getName(). 18 | *- @Brief: see below 19 | * -#step1：调用Thread.currentThread()的getName()，确认返回main。 20 | *- @Expect: expected.txt 21 | *- @Priority: High 22 | *- @Source: ThreadTest.java 23 | *- @ExecuteClass: ThreadTest 24 | *- @ExecuteArgs: 25 | */ 26 | 27 | public class ThreadTest { 28 | /** 29 | * Verify currentThread() 30 | */ 31 | public static void main(String[] args) throws Exception { 32 | System.out.println(Thread.currentThread().getName()); 33 | } 34 | } 35 | // EXEC:%maple %f %build_option -o %n.so 36 | // EXEC:%run %n.so %n %run_option | compare %f 37 | // ASSERT: scan-full main\n -------------------------------------------------------------------------------- /tools/README: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/c2s/OpenArkCompiler/1755550ea22eb185cbef8cc5864fa273caebf95a/tools/README --------------------------------------------------------------------------------