Merge "Use the new HCurrentMethod in HLoadString."
diff --git a/build/Android.gtest.mk b/build/Android.gtest.mk
index 0876cc0..5052187 100644
--- a/build/Android.gtest.mk
+++ b/build/Android.gtest.mk
@@ -393,7 +393,7 @@
.PHONY: valgrind-$$(gtest_rule)
-valgrind-$$(gtest_rule): $$(gtest_deps) $(ART_VALGRIND_DEPENDENCIES)
+valgrind-$$(gtest_rule): $$(gtest_exe) $$(gtest_deps) $(ART_VALGRIND_DEPENDENCIES)
$(hide) $$(call ART_TEST_SKIP,$$@) && \
VALGRIND_LIB=$(HOST_OUT)/lib64/valgrind \
$(HOST_OUT_EXECUTABLES)/valgrind --leak-check=full --error-exitcode=1 $$< && \
diff --git a/compiler/dex/quick/codegen_util.cc b/compiler/dex/quick/codegen_util.cc
index 86bb69d..dc8bf1a 100644
--- a/compiler/dex/quick/codegen_util.cc
+++ b/compiler/dex/quick/codegen_util.cc
@@ -670,7 +670,7 @@
void Mir2Lir::CreateMappingTables() {
- bool generate_src_map = cu_->compiler_driver->GetCompilerOptions().GetIncludeDebugSymbols();
+ bool generate_src_map = cu_->compiler_driver->GetCompilerOptions().GetGenerateDebugInfo();
uint32_t pc2dex_data_size = 0u;
uint32_t pc2dex_entries = 0u;
@@ -1071,7 +1071,7 @@
pc_rel_temp_(nullptr),
dex_cache_arrays_min_offset_(std::numeric_limits<uint32_t>::max()),
cfi_(&last_lir_insn_,
- cu->compiler_driver->GetCompilerOptions().GetIncludeCFI(),
+ cu->compiler_driver->GetCompilerOptions().GetGenerateDebugInfo(),
arena),
in_to_reg_storage_mapping_(arena) {
switch_tables_.reserve(4);
diff --git a/compiler/dex/quick/quick_cfi_test.cc b/compiler/dex/quick/quick_cfi_test.cc
index b3c7355..87bbe14 100644
--- a/compiler/dex/quick/quick_cfi_test.cc
+++ b/compiler/dex/quick/quick_cfi_test.cc
@@ -59,8 +59,7 @@
false,
CompilerOptions::kDefaultTopKProfileThreshold,
false,
- true, // include_debug_symbols.
- true, // include_cfi
+ true, // generate_debug_info.
false,
false,
false,
diff --git a/compiler/dex/quick/x86/quick_assemble_x86_test.cc b/compiler/dex/quick/x86/quick_assemble_x86_test.cc
index f58f206..798e23f 100644
--- a/compiler/dex/quick/x86/quick_assemble_x86_test.cc
+++ b/compiler/dex/quick/x86/quick_assemble_x86_test.cc
@@ -42,8 +42,7 @@
false,
CompilerOptions::kDefaultTopKProfileThreshold,
false,
- false,
- false,
+ CompilerOptions::kDefaultGenerateDebugInfo,
false,
false,
false,
diff --git a/compiler/driver/compiler_options.cc b/compiler/driver/compiler_options.cc
index c5fc98a..226e6b7 100644
--- a/compiler/driver/compiler_options.cc
+++ b/compiler/driver/compiler_options.cc
@@ -30,8 +30,7 @@
include_patch_information_(kDefaultIncludePatchInformation),
top_k_profile_threshold_(kDefaultTopKProfileThreshold),
debuggable_(false),
- include_debug_symbols_(kDefaultIncludeDebugSymbols),
- include_cfi_(false),
+ generate_debug_info_(kDefaultGenerateDebugInfo),
implicit_null_checks_(true),
implicit_so_checks_(true),
implicit_suspend_checks_(false),
@@ -56,8 +55,7 @@
bool include_patch_information,
double top_k_profile_threshold,
bool debuggable,
- bool include_debug_symbols,
- bool include_cfi,
+ bool generate_debug_info,
bool implicit_null_checks,
bool implicit_so_checks,
bool implicit_suspend_checks,
@@ -76,8 +74,7 @@
include_patch_information_(include_patch_information),
top_k_profile_threshold_(top_k_profile_threshold),
debuggable_(debuggable),
- include_debug_symbols_(include_debug_symbols),
- include_cfi_(include_cfi),
+ generate_debug_info_(generate_debug_info),
implicit_null_checks_(implicit_null_checks),
implicit_so_checks_(implicit_so_checks),
implicit_suspend_checks_(implicit_suspend_checks),
diff --git a/compiler/driver/compiler_options.h b/compiler/driver/compiler_options.h
index bf3f8ec..356663b 100644
--- a/compiler/driver/compiler_options.h
+++ b/compiler/driver/compiler_options.h
@@ -49,7 +49,7 @@
static const size_t kDefaultTinyMethodThreshold = 20;
static const size_t kDefaultNumDexMethodsThreshold = 900;
static constexpr double kDefaultTopKProfileThreshold = 90.0;
- static const bool kDefaultIncludeDebugSymbols = kIsDebugBuild;
+ static const bool kDefaultGenerateDebugInfo = kIsDebugBuild;
static const bool kDefaultIncludePatchInformation = false;
CompilerOptions();
@@ -64,8 +64,7 @@
bool include_patch_information,
double top_k_profile_threshold,
bool debuggable,
- bool include_debug_symbols,
- bool include_cfi,
+ bool generate_debug_info,
bool implicit_null_checks,
bool implicit_so_checks,
bool implicit_suspend_checks,
@@ -146,13 +145,8 @@
return debuggable_;
}
- bool GetIncludeDebugSymbols() const {
- return include_debug_symbols_;
- }
-
- bool GetIncludeCFI() const {
- // include-debug-symbols implies include-cfi.
- return include_cfi_ || include_debug_symbols_;
+ bool GetGenerateDebugInfo() const {
+ return generate_debug_info_;
}
bool GetImplicitNullChecks() const {
@@ -212,8 +206,7 @@
// When using a profile file only the top K% of the profiled samples will be compiled.
const double top_k_profile_threshold_;
const bool debuggable_;
- const bool include_debug_symbols_;
- const bool include_cfi_;
+ const bool generate_debug_info_;
const bool implicit_null_checks_;
const bool implicit_so_checks_;
const bool implicit_suspend_checks_;
diff --git a/compiler/elf_writer_quick.cc b/compiler/elf_writer_quick.cc
index 3f0a80b..dce1e86 100644
--- a/compiler/elf_writer_quick.cc
+++ b/compiler/elf_writer_quick.cc
@@ -192,7 +192,8 @@
std::unique_ptr<RawSection> debug_line_oat_patches(new RawSection(
".debug_line.oat_patches", SHT_OAT_PATCH));
if (!oat_writer->GetMethodDebugInfo().empty()) {
- if (compiler_driver_->GetCompilerOptions().GetIncludeCFI()) {
+ if (compiler_driver_->GetCompilerOptions().GetGenerateDebugInfo()) {
+ // Generate CFI (stack unwinding information).
if (kCFIFormat == dwarf::DW_EH_FRAME_FORMAT) {
dwarf::WriteCFISection(
compiler_driver_, oat_writer,
@@ -213,8 +214,6 @@
debug_frame_oat_patches->GetBuffer());
builder->RegisterSection(debug_frame_oat_patches.get());
}
- }
- if (compiler_driver_->GetCompilerOptions().GetIncludeDebugSymbols()) {
// Add methods to .symtab.
WriteDebugSymbols(builder.get(), oat_writer);
// Generate DWARF .debug_* sections.
diff --git a/compiler/jit/jit_compiler.cc b/compiler/jit/jit_compiler.cc
index 7ed7097..e28f8f0 100644
--- a/compiler/jit/jit_compiler.cc
+++ b/compiler/jit/jit_compiler.cc
@@ -74,8 +74,7 @@
false,
CompilerOptions::kDefaultTopKProfileThreshold,
false, // TODO: Think about debuggability of JIT-compiled code.
- false,
- false,
+ CompilerOptions::kDefaultGenerateDebugInfo,
false,
false,
false,
diff --git a/compiler/jni/quick/jni_compiler.cc b/compiler/jni/quick/jni_compiler.cc
index a06303d..573c088 100644
--- a/compiler/jni/quick/jni_compiler.cc
+++ b/compiler/jni/quick/jni_compiler.cc
@@ -94,7 +94,7 @@
// Assembler that holds generated instructions
std::unique_ptr<Assembler> jni_asm(Assembler::Create(instruction_set));
- jni_asm->cfi().SetEnabled(driver->GetCompilerOptions().GetIncludeCFI());
+ jni_asm->cfi().SetEnabled(driver->GetCompilerOptions().GetGenerateDebugInfo());
// Offsets into data structures
// TODO: if cross compiling these offsets are for the host not the target
diff --git a/compiler/oat_writer.cc b/compiler/oat_writer.cc
index 745cdcf..8f153b1 100644
--- a/compiler/oat_writer.cc
+++ b/compiler/oat_writer.cc
@@ -449,8 +449,7 @@
}
}
- if (writer_->compiler_driver_->GetCompilerOptions().GetIncludeDebugSymbols() ||
- writer_->compiler_driver_->GetCompilerOptions().GetIncludeCFI()) {
+ if (writer_->compiler_driver_->GetCompilerOptions().GetGenerateDebugInfo()) {
// Record debug information for this function if we are doing that.
const uint32_t quick_code_start = quick_code_offset -
writer_->oat_header_->GetExecutableOffset() - thumb_offset;
diff --git a/compiler/optimizing/optimizing_compiler.cc b/compiler/optimizing/optimizing_compiler.cc
index fa3c310..3123843 100644
--- a/compiler/optimizing/optimizing_compiler.cc
+++ b/compiler/optimizing/optimizing_compiler.cc
@@ -401,7 +401,7 @@
codegen->CompileOptimized(&allocator);
DefaultSrcMap src_mapping_table;
- if (compiler_driver->GetCompilerOptions().GetIncludeDebugSymbols()) {
+ if (compiler_driver->GetCompilerOptions().GetGenerateDebugInfo()) {
codegen->BuildSourceMap(&src_mapping_table);
}
@@ -438,7 +438,7 @@
std::vector<uint8_t> mapping_table;
codegen->BuildMappingTable(&mapping_table);
DefaultSrcMap src_mapping_table;
- if (compiler_driver->GetCompilerOptions().GetIncludeDebugSymbols()) {
+ if (compiler_driver->GetCompilerOptions().GetGenerateDebugInfo()) {
codegen->BuildSourceMap(&src_mapping_table);
}
std::vector<uint8_t> vmap_table;
@@ -534,7 +534,7 @@
return nullptr;
}
codegen->GetAssembler()->cfi().SetEnabled(
- compiler_driver->GetCompilerOptions().GetIncludeCFI());
+ compiler_driver->GetCompilerOptions().GetGenerateDebugInfo());
PassInfoPrinter pass_info_printer(graph,
method_name.c_str(),
diff --git a/dex2oat/dex2oat.cc b/dex2oat/dex2oat.cc
index e0f367e..cf4ef3e 100644
--- a/dex2oat/dex2oat.cc
+++ b/dex2oat/dex2oat.cc
@@ -230,14 +230,14 @@
UsageError("");
UsageError(" --no-include-patch-information: Do not include patching information.");
UsageError("");
- UsageError(" --include-debug-symbols: Include ELF symbols in this oat file");
+ UsageError(" -g");
+ UsageError(" --generate-debug-info: Generate debug information for native debugging,");
+ UsageError(" such as stack unwinding information, ELF symbols and DWARF sections.");
+ UsageError(" This generates all the available information. Unneeded parts can be");
+ UsageError(" stripped using standard command line tools such as strip or objcopy.");
+ UsageError(" (enabled by default in debug builds, disabled by default otherwise)");
UsageError("");
- UsageError(" --no-include-debug-symbols: Do not include ELF symbols in this oat file");
- UsageError("");
- UsageError(" --include-cfi: Include call frame information in the .eh_frame section.");
- UsageError(" The --include-debug-symbols option implies --include-cfi.");
- UsageError("");
- UsageError(" --no-include-cfi: Do not include call frame information in the .eh_frame section.");
+ UsageError(" --no-generate-debug-info: Do not generate debug information for native debugging.");
UsageError("");
UsageError(" --runtime-arg <argument>: used to specify various arguments for the runtime,");
UsageError(" such as initial heap size, maximum heap size, and verbose output.");
@@ -499,8 +499,7 @@
bool debuggable = false;
bool include_patch_information = CompilerOptions::kDefaultIncludePatchInformation;
- bool include_debug_symbols = kIsDebugBuild;
- bool include_cfi = kIsDebugBuild;
+ bool generate_debug_info = kIsDebugBuild;
bool watch_dog_enabled = true;
bool abort_on_hard_verifier_error = false;
bool requested_specific_compiler = false;
@@ -682,18 +681,13 @@
dump_cfg_file_name_ = option.substr(strlen("--dump-cfg=")).data();
} else if (option == "--dump-stats") {
dump_stats_ = true;
- } else if (option == "--include-debug-symbols" || option == "--no-strip-symbols") {
- include_debug_symbols = true;
- } else if (option == "--no-include-debug-symbols" || option == "--strip-symbols") {
- include_debug_symbols = false;
- } else if (option == "--include-cfi") {
- include_cfi = true;
- } else if (option == "--no-include-cfi") {
- include_cfi = false;
+ } else if (option == "--generate-debug-info" || option == "-g") {
+ generate_debug_info = true;
+ } else if (option == "--no-generate-debug-info") {
+ generate_debug_info = false;
} else if (option == "--debuggable") {
debuggable = true;
- include_debug_symbols = true;
- include_cfi = true;
+ generate_debug_info = true;
} else if (option.starts_with("--profile-file=")) {
profile_file_ = option.substr(strlen("--profile-file=")).data();
VLOG(compiler) << "dex2oat: profile file is " << profile_file_;
@@ -933,10 +927,6 @@
break;
}
- if (debuggable) {
- // TODO: Consider adding CFI info and symbols here.
- }
-
compiler_options_.reset(new CompilerOptions(compiler_filter,
huge_method_threshold,
large_method_threshold,
@@ -946,8 +936,7 @@
include_patch_information,
top_k_profile_threshold,
debuggable,
- include_debug_symbols,
- include_cfi,
+ generate_debug_info,
implicit_null_checks,
implicit_so_checks,
implicit_suspend_checks,
diff --git a/runtime/arch/mips/asm_support_mips.h b/runtime/arch/mips/asm_support_mips.h
index 02c0982..390c606 100644
--- a/runtime/arch/mips/asm_support_mips.h
+++ b/runtime/arch/mips/asm_support_mips.h
@@ -19,7 +19,7 @@
#include "asm_support.h"
-#define FRAME_SIZE_SAVE_ALL_CALLEE_SAVE 48
+#define FRAME_SIZE_SAVE_ALL_CALLEE_SAVE 96
#define FRAME_SIZE_REFS_ONLY_CALLEE_SAVE 48
#define FRAME_SIZE_REFS_AND_ARGS_CALLEE_SAVE 64
diff --git a/runtime/arch/mips/quick_entrypoints_mips.S b/runtime/arch/mips/quick_entrypoints_mips.S
index 89d1449..c00d6cb 100644
--- a/runtime/arch/mips/quick_entrypoints_mips.S
+++ b/runtime/arch/mips/quick_entrypoints_mips.S
@@ -37,36 +37,44 @@
* Reserves FRAME_SIZE_SAVE_ALL_CALLEE_SAVE + ARG_SLOT_SIZE bytes on the stack
*/
.macro SETUP_SAVE_ALL_CALLEE_SAVE_FRAME
- addiu $sp, $sp, -48
- .cfi_adjust_cfa_offset 48
+ addiu $sp, $sp, -96
+ .cfi_adjust_cfa_offset 96
// Ugly compile-time check, but we only have the preprocessor.
-#if (FRAME_SIZE_SAVE_ALL_CALLEE_SAVE != 48)
+#if (FRAME_SIZE_SAVE_ALL_CALLEE_SAVE != 96)
#error "SAVE_ALL_CALLEE_SAVE_FRAME(MIPS) size not as expected."
#endif
- sw $ra, 44($sp)
- .cfi_rel_offset 31, 44
- sw $s8, 40($sp)
- .cfi_rel_offset 30, 40
- sw $gp, 36($sp)
- .cfi_rel_offset 28, 36
- sw $s7, 32($sp)
- .cfi_rel_offset 23, 32
- sw $s6, 28($sp)
- .cfi_rel_offset 22, 28
- sw $s5, 24($sp)
- .cfi_rel_offset 21, 24
- sw $s4, 20($sp)
- .cfi_rel_offset 20, 20
- sw $s3, 16($sp)
- .cfi_rel_offset 19, 16
- sw $s2, 12($sp)
- .cfi_rel_offset 18, 12
- sw $s1, 8($sp)
- .cfi_rel_offset 17, 8
- sw $s0, 4($sp)
- .cfi_rel_offset 16, 4
+ sw $ra, 92($sp)
+ .cfi_rel_offset 31, 92
+ sw $s8, 88($sp)
+ .cfi_rel_offset 30, 88
+ sw $gp, 84($sp)
+ .cfi_rel_offset 28, 84
+ sw $s7, 80($sp)
+ .cfi_rel_offset 23, 80
+ sw $s6, 76($sp)
+ .cfi_rel_offset 22, 76
+ sw $s5, 72($sp)
+ .cfi_rel_offset 21, 72
+ sw $s4, 68($sp)
+ .cfi_rel_offset 20, 68
+ sw $s3, 64($sp)
+ .cfi_rel_offset 19, 64
+ sw $s2, 60($sp)
+ .cfi_rel_offset 18, 60
+ sw $s1, 56($sp)
+ .cfi_rel_offset 17, 56
+ sw $s0, 52($sp)
+ .cfi_rel_offset 16, 52
+
+ SDu $f30, $f31, 44, $sp, $t1
+ SDu $f28, $f29, 36, $sp, $t1
+ SDu $f26, $f27, 28, $sp, $t1
+ SDu $f24, $f25, 20, $sp, $t1
+ SDu $f22, $f23, 12, $sp, $t1
+ SDu $f20, $f21, 4, $sp, $t1
+
# 1 word for holding Method*
lw $t0, %got(_ZN3art7Runtime9instance_E)($gp)
diff --git a/runtime/arch/mips/quick_method_frame_info_mips.h b/runtime/arch/mips/quick_method_frame_info_mips.h
index 97b295f..dd5ac80 100644
--- a/runtime/arch/mips/quick_method_frame_info_mips.h
+++ b/runtime/arch/mips/quick_method_frame_info_mips.h
@@ -32,6 +32,10 @@
(1 << art::mips::A1) | (1 << art::mips::A2) | (1 << art::mips::A3);
static constexpr uint32_t kMipsCalleeSaveAllSpills =
(1 << art::mips::S0) | (1 << art::mips::S1);
+static constexpr uint32_t kMipsCalleeSaveAllFPSpills =
+ (1 << art::mips::F20) | (1 << art::mips::F21) | (1 << art::mips::F22) | (1 << art::mips::F23) |
+ (1 << art::mips::F24) | (1 << art::mips::F25) | (1 << art::mips::F26) | (1 << art::mips::F27) |
+ (1 << art::mips::F28) | (1 << art::mips::F29) | (1 << art::mips::F30) | (1 << art::mips::F31);
constexpr uint32_t MipsCalleeSaveCoreSpills(Runtime::CalleeSaveType type) {
return kMipsCalleeSaveRefSpills |
@@ -39,15 +43,20 @@
(type == Runtime::kSaveAll ? kMipsCalleeSaveAllSpills : 0) | (1 << art::mips::RA);
}
+constexpr uint32_t MipsCalleeSaveFPSpills(Runtime::CalleeSaveType type) {
+ return type == Runtime::kSaveAll ? kMipsCalleeSaveAllFPSpills : 0;
+}
+
constexpr uint32_t MipsCalleeSaveFrameSize(Runtime::CalleeSaveType type) {
return RoundUp((POPCOUNT(MipsCalleeSaveCoreSpills(type)) /* gprs */ +
+ POPCOUNT(MipsCalleeSaveFPSpills(type)) /* fprs */ +
1 /* Method* */) * kMipsPointerSize, kStackAlignment);
}
constexpr QuickMethodFrameInfo MipsCalleeSaveMethodFrameInfo(Runtime::CalleeSaveType type) {
return QuickMethodFrameInfo(MipsCalleeSaveFrameSize(type),
MipsCalleeSaveCoreSpills(type),
- 0u);
+ MipsCalleeSaveFPSpills(type));
}
} // namespace mips
diff --git a/runtime/java_vm_ext.cc b/runtime/java_vm_ext.cc
index b795d72..3142089 100644
--- a/runtime/java_vm_ext.cc
+++ b/runtime/java_vm_ext.cc
@@ -562,6 +562,11 @@
return globals_.SynchronizedGet(self, &globals_lock_, ref);
}
+void JavaVMExt::UpdateGlobal(Thread* self, IndirectRef ref, mirror::Object* result) {
+ WriterMutexLock mu(self, globals_lock_);
+ globals_.Update(ref, result);
+}
+
mirror::Object* JavaVMExt::DecodeWeakGlobal(Thread* self, IndirectRef ref) {
MutexLock mu(self, weak_globals_lock_);
while (UNLIKELY(!allow_new_weak_globals_)) {
@@ -570,6 +575,11 @@
return weak_globals_.Get(ref);
}
+void JavaVMExt::UpdateWeakGlobal(Thread* self, IndirectRef ref, mirror::Object* result) {
+ MutexLock mu(self, weak_globals_lock_);
+ weak_globals_.Update(ref, result);
+}
+
void JavaVMExt::DumpReferenceTables(std::ostream& os) {
Thread* self = Thread::Current();
{
diff --git a/runtime/java_vm_ext.h b/runtime/java_vm_ext.h
index deec6a9..594027c 100644
--- a/runtime/java_vm_ext.h
+++ b/runtime/java_vm_ext.h
@@ -125,9 +125,17 @@
mirror::Object* DecodeGlobal(Thread* self, IndirectRef ref)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ void UpdateGlobal(Thread* self, IndirectRef ref, mirror::Object* result)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
+ LOCKS_EXCLUDED(globals_lock_);
+
mirror::Object* DecodeWeakGlobal(Thread* self, IndirectRef ref)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ void UpdateWeakGlobal(Thread* self, IndirectRef ref, mirror::Object* result)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
+ LOCKS_EXCLUDED(weak_globals_lock_);
+
const JNIInvokeInterface* GetUncheckedFunctions() const {
return unchecked_functions_;
}
diff --git a/runtime/native/dalvik_system_ZygoteHooks.cc b/runtime/native/dalvik_system_ZygoteHooks.cc
index 1a7a3e5..1d06706 100644
--- a/runtime/native/dalvik_system_ZygoteHooks.cc
+++ b/runtime/native/dalvik_system_ZygoteHooks.cc
@@ -65,7 +65,7 @@
DEBUG_ENABLE_SAFEMODE = 1 << 3,
DEBUG_ENABLE_JNI_LOGGING = 1 << 4,
DEBUG_ENABLE_JIT = 1 << 5,
- DEBUG_GENERATE_CFI = 1 << 6,
+ DEBUG_GENERATE_DEBUG_INFO = 1 << 6,
};
Runtime* const runtime = Runtime::Current();
@@ -112,10 +112,10 @@
}
runtime->GetJITOptions()->SetUseJIT(use_jit);
- const bool generate_cfi = (debug_flags & DEBUG_GENERATE_CFI) != 0;
- if (generate_cfi) {
- runtime->AddCompilerOption("--include-cfi");
- debug_flags &= ~DEBUG_GENERATE_CFI;
+ const bool generate_debug_info = (debug_flags & DEBUG_GENERATE_DEBUG_INFO) != 0;
+ if (generate_debug_info) {
+ runtime->AddCompilerOption("--generate-debug-info");
+ debug_flags &= ~DEBUG_GENERATE_DEBUG_INFO;
}
// This is for backwards compatibility with Dalvik.
diff --git a/runtime/reflection.cc b/runtime/reflection.cc
index d321d27..f8c7081 100644
--- a/runtime/reflection.cc
+++ b/runtime/reflection.cc
@@ -464,7 +464,7 @@
InvokeWithArgArray(soa, method, &arg_array, &result, shorty);
if (is_string_init) {
// For string init, remap original receiver to StringFactory result.
- soa.Self()->GetJniEnv()->locals.Update(obj, result.GetL());
+ UpdateReference(soa.Self(), obj, result.GetL());
}
return result;
}
@@ -494,7 +494,7 @@
InvokeWithArgArray(soa, method, &arg_array, &result, shorty);
if (is_string_init) {
// For string init, remap original receiver to StringFactory result.
- soa.Self()->GetJniEnv()->locals.Update(obj, result.GetL());
+ UpdateReference(soa.Self(), obj, result.GetL());
}
return result;
}
@@ -525,7 +525,7 @@
InvokeWithArgArray(soa, method, &arg_array, &result, shorty);
if (is_string_init) {
// For string init, remap original receiver to StringFactory result.
- soa.Self()->GetJniEnv()->locals.Update(obj, result.GetL());
+ UpdateReference(soa.Self(), obj, result.GetL());
}
return result;
}
@@ -556,7 +556,7 @@
InvokeWithArgArray(soa, method, &arg_array, &result, shorty);
if (is_string_init) {
// For string init, remap original receiver to StringFactory result.
- soa.Self()->GetJniEnv()->locals.Update(obj, result.GetL());
+ UpdateReference(soa.Self(), obj, result.GetL());
}
return result;
}
@@ -882,4 +882,21 @@
actual_class_name.c_str()).c_str());
}
+// This only works if there's one reference which points to the object in obj.
+// Will need to be fixed if there's cases where it's not.
+void UpdateReference(Thread* self, jobject obj, mirror::Object* result) {
+ IndirectRef ref = reinterpret_cast<IndirectRef>(obj);
+ IndirectRefKind kind = GetIndirectRefKind(ref);
+ if (kind == kLocal) {
+ self->GetJniEnv()->locals.Update(obj, result);
+ } else if (kind == kHandleScopeOrInvalid) {
+ LOG(FATAL) << "Unsupported UpdateReference for kind kHandleScopeOrInvalid";
+ } else if (kind == kGlobal) {
+ self->GetJniEnv()->vm->UpdateGlobal(self, ref, result);
+ } else {
+ DCHECK_EQ(kind, kWeakGlobal);
+ self->GetJniEnv()->vm->UpdateWeakGlobal(self, ref, result);
+ }
+}
+
} // namespace art
diff --git a/runtime/reflection.h b/runtime/reflection.h
index 6b5ffc7..df3b9d3 100644
--- a/runtime/reflection.h
+++ b/runtime/reflection.h
@@ -85,6 +85,9 @@
void InvalidReceiverError(mirror::Object* o, mirror::Class* c)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+void UpdateReference(Thread* self, jobject obj, mirror::Object* result)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
} // namespace art
#endif // ART_RUNTIME_REFLECTION_H_
diff --git a/test/004-JniTest/jni_test.cc b/test/004-JniTest/jni_test.cc
index 1ec0cf2..71a2b2d 100644
--- a/test/004-JniTest/jni_test.cc
+++ b/test/004-JniTest/jni_test.cc
@@ -604,4 +604,20 @@
args4[0].l = string_arg;
env->CallVoidMethodA(s3, mid3, args3);
env->CallNonvirtualVoidMethodA(s4, c, mid4, args4);
+
+ // Test with global and weak global references
+ jstring s5 = reinterpret_cast<jstring>(env->AllocObject(c));
+ assert(s5 != nullptr);
+ s5 = reinterpret_cast<jstring>(env->NewGlobalRef(s5));
+ jstring s6 = reinterpret_cast<jstring>(env->AllocObject(c));
+ assert(s6 != nullptr);
+ s6 = reinterpret_cast<jstring>(env->NewWeakGlobalRef(s6));
+
+ env->CallVoidMethod(s5, mid1);
+ env->CallNonvirtualVoidMethod(s6, c, mid2, byte_array);
+ assert(env->GetStringLength(s5) == 0);
+ assert(env->GetStringLength(s6) == byte_array_length);
+ const char* chars6 = env->GetStringUTFChars(s6, nullptr);
+ assert(strcmp(test_array, chars6) == 0);
+ env->ReleaseStringUTFChars(s6, chars6);
}
diff --git a/test/441-checker-inliner/src/Main.java b/test/441-checker-inliner/src/Main.java
index 8894d4e..df969a4 100644
--- a/test/441-checker-inliner/src/Main.java
+++ b/test/441-checker-inliner/src/Main.java
@@ -16,133 +16,133 @@
public class Main {
- // CHECK-START: void Main.InlineVoid() inliner (before)
- // CHECK-DAG: <<Const42:i\d+>> IntConstant 42
- // CHECK-DAG: InvokeStaticOrDirect
- // CHECK-DAG: InvokeStaticOrDirect [<<Const42>>]
+ /// CHECK-START: void Main.InlineVoid() inliner (before)
+ /// CHECK-DAG: <<Const42:i\d+>> IntConstant 42
+ /// CHECK-DAG: InvokeStaticOrDirect
+ /// CHECK-DAG: InvokeStaticOrDirect [<<Const42>>]
- // CHECK-START: void Main.InlineVoid() inliner (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: void Main.InlineVoid() inliner (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
public static void InlineVoid() {
returnVoid();
returnVoidWithOneParameter(42);
}
- // CHECK-START: int Main.InlineParameter(int) inliner (before)
- // CHECK-DAG: <<Param:i\d+>> ParameterValue
- // CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect [<<Param>>]
- // CHECK-DAG: Return [<<Result>>]
+ /// CHECK-START: int Main.InlineParameter(int) inliner (before)
+ /// CHECK-DAG: <<Param:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect [<<Param>>]
+ /// CHECK-DAG: Return [<<Result>>]
- // CHECK-START: int Main.InlineParameter(int) inliner (after)
- // CHECK-DAG: <<Param:i\d+>> ParameterValue
- // CHECK-DAG: Return [<<Param>>]
+ /// CHECK-START: int Main.InlineParameter(int) inliner (after)
+ /// CHECK-DAG: <<Param:i\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Param>>]
public static int InlineParameter(int a) {
return returnParameter(a);
}
- // CHECK-START: long Main.InlineWideParameter(long) inliner (before)
- // CHECK-DAG: <<Param:j\d+>> ParameterValue
- // CHECK-DAG: <<Result:j\d+>> InvokeStaticOrDirect [<<Param>>]
- // CHECK-DAG: Return [<<Result>>]
+ /// CHECK-START: long Main.InlineWideParameter(long) inliner (before)
+ /// CHECK-DAG: <<Param:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Result:j\d+>> InvokeStaticOrDirect [<<Param>>]
+ /// CHECK-DAG: Return [<<Result>>]
- // CHECK-START: long Main.InlineWideParameter(long) inliner (after)
- // CHECK-DAG: <<Param:j\d+>> ParameterValue
- // CHECK-DAG: Return [<<Param>>]
+ /// CHECK-START: long Main.InlineWideParameter(long) inliner (after)
+ /// CHECK-DAG: <<Param:j\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Param>>]
public static long InlineWideParameter(long a) {
return returnWideParameter(a);
}
- // CHECK-START: java.lang.Object Main.InlineReferenceParameter(java.lang.Object) inliner (before)
- // CHECK-DAG: <<Param:l\d+>> ParameterValue
- // CHECK-DAG: <<Result:l\d+>> InvokeStaticOrDirect [<<Param>>]
- // CHECK-DAG: Return [<<Result>>]
+ /// CHECK-START: java.lang.Object Main.InlineReferenceParameter(java.lang.Object) inliner (before)
+ /// CHECK-DAG: <<Param:l\d+>> ParameterValue
+ /// CHECK-DAG: <<Result:l\d+>> InvokeStaticOrDirect [<<Param>>]
+ /// CHECK-DAG: Return [<<Result>>]
- // CHECK-START: java.lang.Object Main.InlineReferenceParameter(java.lang.Object) inliner (after)
- // CHECK-DAG: <<Param:l\d+>> ParameterValue
- // CHECK-DAG: Return [<<Param>>]
+ /// CHECK-START: java.lang.Object Main.InlineReferenceParameter(java.lang.Object) inliner (after)
+ /// CHECK-DAG: <<Param:l\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Param>>]
public static Object InlineReferenceParameter(Object o) {
return returnReferenceParameter(o);
}
- // CHECK-START: int Main.InlineInt() inliner (before)
- // CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Result>>]
+ /// CHECK-START: int Main.InlineInt() inliner (before)
+ /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Result>>]
- // CHECK-START: int Main.InlineInt() inliner (after)
- // CHECK-DAG: <<Const4:i\d+>> IntConstant 4
- // CHECK-DAG: Return [<<Const4>>]
+ /// CHECK-START: int Main.InlineInt() inliner (after)
+ /// CHECK-DAG: <<Const4:i\d+>> IntConstant 4
+ /// CHECK-DAG: Return [<<Const4>>]
public static int InlineInt() {
return returnInt();
}
- // CHECK-START: long Main.InlineWide() inliner (before)
- // CHECK-DAG: <<Result:j\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Result>>]
+ /// CHECK-START: long Main.InlineWide() inliner (before)
+ /// CHECK-DAG: <<Result:j\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Result>>]
- // CHECK-START: long Main.InlineWide() inliner (after)
- // CHECK-DAG: <<Const8:j\d+>> LongConstant 8
- // CHECK-DAG: Return [<<Const8>>]
+ /// CHECK-START: long Main.InlineWide() inliner (after)
+ /// CHECK-DAG: <<Const8:j\d+>> LongConstant 8
+ /// CHECK-DAG: Return [<<Const8>>]
public static long InlineWide() {
return returnWide();
}
- // CHECK-START: int Main.InlineAdd() inliner (before)
- // CHECK-DAG: <<Const3:i\d+>> IntConstant 3
- // CHECK-DAG: <<Const5:i\d+>> IntConstant 5
- // CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Result>>]
+ /// CHECK-START: int Main.InlineAdd() inliner (before)
+ /// CHECK-DAG: <<Const3:i\d+>> IntConstant 3
+ /// CHECK-DAG: <<Const5:i\d+>> IntConstant 5
+ /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Result>>]
- // CHECK-START: int Main.InlineAdd() inliner (after)
- // CHECK-DAG: <<Const3:i\d+>> IntConstant 3
- // CHECK-DAG: <<Const5:i\d+>> IntConstant 5
- // CHECK-DAG: <<Add:i\d+>> Add [<<Const3>>,<<Const5>>]
- // CHECK-DAG: Return [<<Add>>]
+ /// CHECK-START: int Main.InlineAdd() inliner (after)
+ /// CHECK-DAG: <<Const3:i\d+>> IntConstant 3
+ /// CHECK-DAG: <<Const5:i\d+>> IntConstant 5
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<Const3>>,<<Const5>>]
+ /// CHECK-DAG: Return [<<Add>>]
public static int InlineAdd() {
return returnAdd(3, 5);
}
- // CHECK-START: int Main.InlineFieldAccess() inliner (before)
- // CHECK-DAG: <<After:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<After>>]
+ /// CHECK-START: int Main.InlineFieldAccess() inliner (before)
+ /// CHECK-DAG: <<After:i\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<After>>]
- // CHECK-START: int Main.InlineFieldAccess() inliner (after)
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: <<Before:i\d+>> StaticFieldGet
- // CHECK-DAG: <<After:i\d+>> Add [<<Before>>,<<Const1>>]
- // CHECK-DAG: StaticFieldSet [{{l\d+}},<<After>>]
- // CHECK-DAG: Return [<<After>>]
+ /// CHECK-START: int Main.InlineFieldAccess() inliner (after)
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<Before:i\d+>> StaticFieldGet
+ /// CHECK-DAG: <<After:i\d+>> Add [<<Before>>,<<Const1>>]
+ /// CHECK-DAG: StaticFieldSet [{{l\d+}},<<After>>]
+ /// CHECK-DAG: Return [<<After>>]
- // CHECK-START: int Main.InlineFieldAccess() inliner (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: int Main.InlineFieldAccess() inliner (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
public static int InlineFieldAccess() {
return incCounter();
}
- // CHECK-START: int Main.InlineWithControlFlow(boolean) inliner (before)
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: <<Const3:i\d+>> IntConstant 3
- // CHECK-DAG: <<Const5:i\d+>> IntConstant 5
- // CHECK-DAG: <<Add:i\d+>> InvokeStaticOrDirect [<<Const1>>,<<Const3>>]
- // CHECK-DAG: <<Sub:i\d+>> InvokeStaticOrDirect [<<Const5>>,<<Const3>>]
- // CHECK-DAG: <<Phi:i\d+>> Phi [<<Add>>,<<Sub>>]
- // CHECK-DAG: Return [<<Phi>>]
+ /// CHECK-START: int Main.InlineWithControlFlow(boolean) inliner (before)
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<Const3:i\d+>> IntConstant 3
+ /// CHECK-DAG: <<Const5:i\d+>> IntConstant 5
+ /// CHECK-DAG: <<Add:i\d+>> InvokeStaticOrDirect [<<Const1>>,<<Const3>>]
+ /// CHECK-DAG: <<Sub:i\d+>> InvokeStaticOrDirect [<<Const5>>,<<Const3>>]
+ /// CHECK-DAG: <<Phi:i\d+>> Phi [<<Add>>,<<Sub>>]
+ /// CHECK-DAG: Return [<<Phi>>]
- // CHECK-START: int Main.InlineWithControlFlow(boolean) inliner (after)
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: <<Const3:i\d+>> IntConstant 3
- // CHECK-DAG: <<Const5:i\d+>> IntConstant 5
- // CHECK-DAG: <<Add:i\d+>> Add [<<Const1>>,<<Const3>>]
- // CHECK-DAG: <<Sub:i\d+>> Sub [<<Const5>>,<<Const3>>]
- // CHECK-DAG: <<Phi:i\d+>> Phi [<<Add>>,<<Sub>>]
- // CHECK-DAG: Return [<<Phi>>]
+ /// CHECK-START: int Main.InlineWithControlFlow(boolean) inliner (after)
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<Const3:i\d+>> IntConstant 3
+ /// CHECK-DAG: <<Const5:i\d+>> IntConstant 5
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<Const1>>,<<Const3>>]
+ /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Const5>>,<<Const3>>]
+ /// CHECK-DAG: <<Phi:i\d+>> Phi [<<Add>>,<<Sub>>]
+ /// CHECK-DAG: Return [<<Phi>>]
public static int InlineWithControlFlow(boolean cond) {
int x, const1, const3, const5;
diff --git a/test/442-checker-constant-folding/src/Main.java b/test/442-checker-constant-folding/src/Main.java
index c258db9..b7863be 100644
--- a/test/442-checker-constant-folding/src/Main.java
+++ b/test/442-checker-constant-folding/src/Main.java
@@ -51,14 +51,14 @@
* on negation.
*/
- // CHECK-START: int Main.IntNegation() constant_folding (before)
- // CHECK-DAG: <<Const42:i\d+>> IntConstant 42
- // CHECK-DAG: <<Neg:i\d+>> Neg [<<Const42>>]
- // CHECK-DAG: Return [<<Neg>>]
+ /// CHECK-START: int Main.IntNegation() constant_folding (before)
+ /// CHECK-DAG: <<Const42:i\d+>> IntConstant 42
+ /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Const42>>]
+ /// CHECK-DAG: Return [<<Neg>>]
- // CHECK-START: int Main.IntNegation() constant_folding (after)
- // CHECK-DAG: <<ConstN42:i\d+>> IntConstant -42
- // CHECK-DAG: Return [<<ConstN42>>]
+ /// CHECK-START: int Main.IntNegation() constant_folding (after)
+ /// CHECK-DAG: <<ConstN42:i\d+>> IntConstant -42
+ /// CHECK-DAG: Return [<<ConstN42>>]
public static int IntNegation() {
int x, y;
@@ -72,15 +72,15 @@
* on addition.
*/
- // CHECK-START: int Main.IntAddition1() constant_folding (before)
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: <<Const2:i\d+>> IntConstant 2
- // CHECK-DAG: <<Add:i\d+>> Add [<<Const1>>,<<Const2>>]
- // CHECK-DAG: Return [<<Add>>]
+ /// CHECK-START: int Main.IntAddition1() constant_folding (before)
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<Const2:i\d+>> IntConstant 2
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<Const1>>,<<Const2>>]
+ /// CHECK-DAG: Return [<<Add>>]
- // CHECK-START: int Main.IntAddition1() constant_folding (after)
- // CHECK-DAG: <<Const3:i\d+>> IntConstant 3
- // CHECK-DAG: Return [<<Const3>>]
+ /// CHECK-START: int Main.IntAddition1() constant_folding (after)
+ /// CHECK-DAG: <<Const3:i\d+>> IntConstant 3
+ /// CHECK-DAG: Return [<<Const3>>]
public static int IntAddition1() {
int a, b, c;
@@ -95,19 +95,19 @@
* on addition.
*/
- // CHECK-START: int Main.IntAddition2() constant_folding (before)
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: <<Const2:i\d+>> IntConstant 2
- // CHECK-DAG: <<Const5:i\d+>> IntConstant 5
- // CHECK-DAG: <<Const6:i\d+>> IntConstant 6
- // CHECK-DAG: <<Add1:i\d+>> Add [<<Const1>>,<<Const2>>]
- // CHECK-DAG: <<Add2:i\d+>> Add [<<Const5>>,<<Const6>>]
- // CHECK-DAG: <<Add3:i\d+>> Add [<<Add1>>,<<Add2>>]
- // CHECK-DAG: Return [<<Add3>>]
+ /// CHECK-START: int Main.IntAddition2() constant_folding (before)
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<Const2:i\d+>> IntConstant 2
+ /// CHECK-DAG: <<Const5:i\d+>> IntConstant 5
+ /// CHECK-DAG: <<Const6:i\d+>> IntConstant 6
+ /// CHECK-DAG: <<Add1:i\d+>> Add [<<Const1>>,<<Const2>>]
+ /// CHECK-DAG: <<Add2:i\d+>> Add [<<Const5>>,<<Const6>>]
+ /// CHECK-DAG: <<Add3:i\d+>> Add [<<Add1>>,<<Add2>>]
+ /// CHECK-DAG: Return [<<Add3>>]
- // CHECK-START: int Main.IntAddition2() constant_folding (after)
- // CHECK-DAG: <<Const14:i\d+>> IntConstant 14
- // CHECK-DAG: Return [<<Const14>>]
+ /// CHECK-START: int Main.IntAddition2() constant_folding (after)
+ /// CHECK-DAG: <<Const14:i\d+>> IntConstant 14
+ /// CHECK-DAG: Return [<<Const14>>]
public static int IntAddition2() {
int a, b, c;
@@ -126,15 +126,15 @@
* on subtraction.
*/
- // CHECK-START: int Main.IntSubtraction() constant_folding (before)
- // CHECK-DAG: <<Const6:i\d+>> IntConstant 6
- // CHECK-DAG: <<Const2:i\d+>> IntConstant 2
- // CHECK-DAG: <<Sub:i\d+>> Sub [<<Const6>>,<<Const2>>]
- // CHECK-DAG: Return [<<Sub>>]
+ /// CHECK-START: int Main.IntSubtraction() constant_folding (before)
+ /// CHECK-DAG: <<Const6:i\d+>> IntConstant 6
+ /// CHECK-DAG: <<Const2:i\d+>> IntConstant 2
+ /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Const6>>,<<Const2>>]
+ /// CHECK-DAG: Return [<<Sub>>]
- // CHECK-START: int Main.IntSubtraction() constant_folding (after)
- // CHECK-DAG: <<Const4:i\d+>> IntConstant 4
- // CHECK-DAG: Return [<<Const4>>]
+ /// CHECK-START: int Main.IntSubtraction() constant_folding (after)
+ /// CHECK-DAG: <<Const4:i\d+>> IntConstant 4
+ /// CHECK-DAG: Return [<<Const4>>]
public static int IntSubtraction() {
int a, b, c;
@@ -149,15 +149,15 @@
* on addition.
*/
- // CHECK-START: long Main.LongAddition() constant_folding (before)
- // CHECK-DAG: <<Const1:j\d+>> LongConstant 1
- // CHECK-DAG: <<Const2:j\d+>> LongConstant 2
- // CHECK-DAG: <<Add:j\d+>> Add [<<Const1>>,<<Const2>>]
- // CHECK-DAG: Return [<<Add>>]
+ /// CHECK-START: long Main.LongAddition() constant_folding (before)
+ /// CHECK-DAG: <<Const1:j\d+>> LongConstant 1
+ /// CHECK-DAG: <<Const2:j\d+>> LongConstant 2
+ /// CHECK-DAG: <<Add:j\d+>> Add [<<Const1>>,<<Const2>>]
+ /// CHECK-DAG: Return [<<Add>>]
- // CHECK-START: long Main.LongAddition() constant_folding (after)
- // CHECK-DAG: <<Const3:j\d+>> LongConstant 3
- // CHECK-DAG: Return [<<Const3>>]
+ /// CHECK-START: long Main.LongAddition() constant_folding (after)
+ /// CHECK-DAG: <<Const3:j\d+>> LongConstant 3
+ /// CHECK-DAG: Return [<<Const3>>]
public static long LongAddition() {
long a, b, c;
@@ -172,15 +172,15 @@
* on subtraction.
*/
- // CHECK-START: long Main.LongSubtraction() constant_folding (before)
- // CHECK-DAG: <<Const6:j\d+>> LongConstant 6
- // CHECK-DAG: <<Const2:j\d+>> LongConstant 2
- // CHECK-DAG: <<Sub:j\d+>> Sub [<<Const6>>,<<Const2>>]
- // CHECK-DAG: Return [<<Sub>>]
+ /// CHECK-START: long Main.LongSubtraction() constant_folding (before)
+ /// CHECK-DAG: <<Const6:j\d+>> LongConstant 6
+ /// CHECK-DAG: <<Const2:j\d+>> LongConstant 2
+ /// CHECK-DAG: <<Sub:j\d+>> Sub [<<Const6>>,<<Const2>>]
+ /// CHECK-DAG: Return [<<Sub>>]
- // CHECK-START: long Main.LongSubtraction() constant_folding (after)
- // CHECK-DAG: <<Const4:j\d+>> LongConstant 4
- // CHECK-DAG: Return [<<Const4>>]
+ /// CHECK-START: long Main.LongSubtraction() constant_folding (after)
+ /// CHECK-DAG: <<Const4:j\d+>> LongConstant 4
+ /// CHECK-DAG: Return [<<Const4>>]
public static long LongSubtraction() {
long a, b, c;
@@ -194,15 +194,15 @@
* Three-register program with a constant (static) condition.
*/
- // CHECK-START: int Main.StaticCondition() constant_folding (before)
- // CHECK-DAG: <<Const7:i\d+>> IntConstant 7
- // CHECK-DAG: <<Const2:i\d+>> IntConstant 2
- // CHECK-DAG: <<Cond:z\d+>> GreaterThanOrEqual [<<Const7>>,<<Const2>>]
- // CHECK-DAG: If [<<Cond>>]
+ /// CHECK-START: int Main.StaticCondition() constant_folding (before)
+ /// CHECK-DAG: <<Const7:i\d+>> IntConstant 7
+ /// CHECK-DAG: <<Const2:i\d+>> IntConstant 2
+ /// CHECK-DAG: <<Cond:z\d+>> GreaterThanOrEqual [<<Const7>>,<<Const2>>]
+ /// CHECK-DAG: If [<<Cond>>]
- // CHECK-START: int Main.StaticCondition() constant_folding (after)
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: If [<<Const1>>]
+ /// CHECK-START: int Main.StaticCondition() constant_folding (after)
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: If [<<Const1>>]
public static int StaticCondition() {
int a, b, c;
@@ -224,19 +224,19 @@
* (forward) post-order traversal of the the dominator tree.
*/
- // CHECK-START: int Main.JumpsAndConditionals(boolean) constant_folding (before)
- // CHECK-DAG: <<Const2:i\d+>> IntConstant 2
- // CHECK-DAG: <<Const5:i\d+>> IntConstant 5
- // CHECK-DAG: <<Add:i\d+>> Add [<<Const5>>,<<Const2>>]
- // CHECK-DAG: <<Sub:i\d+>> Sub [<<Const5>>,<<Const2>>]
- // CHECK-DAG: <<Phi:i\d+>> Phi [<<Add>>,<<Sub>>]
- // CHECK-DAG: Return [<<Phi>>]
+ /// CHECK-START: int Main.JumpsAndConditionals(boolean) constant_folding (before)
+ /// CHECK-DAG: <<Const2:i\d+>> IntConstant 2
+ /// CHECK-DAG: <<Const5:i\d+>> IntConstant 5
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<Const5>>,<<Const2>>]
+ /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Const5>>,<<Const2>>]
+ /// CHECK-DAG: <<Phi:i\d+>> Phi [<<Add>>,<<Sub>>]
+ /// CHECK-DAG: Return [<<Phi>>]
- // CHECK-START: int Main.JumpsAndConditionals(boolean) constant_folding (after)
- // CHECK-DAG: <<Const3:i\d+>> IntConstant 3
- // CHECK-DAG: <<Const7:i\d+>> IntConstant 7
- // CHECK-DAG: <<Phi:i\d+>> Phi [<<Const7>>,<<Const3>>]
- // CHECK-DAG: Return [<<Phi>>]
+ /// CHECK-START: int Main.JumpsAndConditionals(boolean) constant_folding (after)
+ /// CHECK-DAG: <<Const3:i\d+>> IntConstant 3
+ /// CHECK-DAG: <<Const7:i\d+>> IntConstant 7
+ /// CHECK-DAG: <<Phi:i\d+>> Phi [<<Const7>>,<<Const3>>]
+ /// CHECK-DAG: Return [<<Phi>>]
public static int JumpsAndConditionals(boolean cond) {
int a, b, c;
@@ -253,388 +253,388 @@
* Test optimizations of arithmetic identities yielding a constant result.
*/
- // CHECK-START: int Main.And0(int) constant_folding (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<And:i\d+>> And [<<Arg>>,<<Const0>>]
- // CHECK-DAG: Return [<<And>>]
+ /// CHECK-START: int Main.And0(int) constant_folding (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<And:i\d+>> And [<<Arg>>,<<Const0>>]
+ /// CHECK-DAG: Return [<<And>>]
- // CHECK-START: int Main.And0(int) constant_folding (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-NOT: And
- // CHECK-DAG: Return [<<Const0>>]
+ /// CHECK-START: int Main.And0(int) constant_folding (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-NOT: And
+ /// CHECK-DAG: Return [<<Const0>>]
public static int And0(int arg) {
return arg & 0;
}
- // CHECK-START: long Main.Mul0(long) constant_folding (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Const0:j\d+>> LongConstant 0
- // CHECK-DAG: <<Mul:j\d+>> Mul [<<Arg>>,<<Const0>>]
- // CHECK-DAG: Return [<<Mul>>]
+ /// CHECK-START: long Main.Mul0(long) constant_folding (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:j\d+>> LongConstant 0
+ /// CHECK-DAG: <<Mul:j\d+>> Mul [<<Arg>>,<<Const0>>]
+ /// CHECK-DAG: Return [<<Mul>>]
- // CHECK-START: long Main.Mul0(long) constant_folding (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Const0:j\d+>> LongConstant 0
- // CHECK-NOT: Mul
- // CHECK-DAG: Return [<<Const0>>]
+ /// CHECK-START: long Main.Mul0(long) constant_folding (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:j\d+>> LongConstant 0
+ /// CHECK-NOT: Mul
+ /// CHECK-DAG: Return [<<Const0>>]
public static long Mul0(long arg) {
return arg * 0;
}
- // CHECK-START: int Main.OrAllOnes(int) constant_folding (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<ConstF:i\d+>> IntConstant -1
- // CHECK-DAG: <<Or:i\d+>> Or [<<Arg>>,<<ConstF>>]
- // CHECK-DAG: Return [<<Or>>]
+ /// CHECK-START: int Main.OrAllOnes(int) constant_folding (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstF:i\d+>> IntConstant -1
+ /// CHECK-DAG: <<Or:i\d+>> Or [<<Arg>>,<<ConstF>>]
+ /// CHECK-DAG: Return [<<Or>>]
- // CHECK-START: int Main.OrAllOnes(int) constant_folding (after)
- // CHECK-DAG: <<ConstF:i\d+>> IntConstant -1
- // CHECK-NOT: Or
- // CHECK-DAG: Return [<<ConstF>>]
+ /// CHECK-START: int Main.OrAllOnes(int) constant_folding (after)
+ /// CHECK-DAG: <<ConstF:i\d+>> IntConstant -1
+ /// CHECK-NOT: Or
+ /// CHECK-DAG: Return [<<ConstF>>]
public static int OrAllOnes(int arg) {
return arg | -1;
}
- // CHECK-START: long Main.Rem0(long) constant_folding (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Const0:j\d+>> LongConstant 0
- // CHECK-DAG: <<DivZeroCheck:j\d+>> DivZeroCheck [<<Arg>>]
- // CHECK-DAG: <<Rem:j\d+>> Rem [<<Const0>>,<<DivZeroCheck>>]
- // CHECK-DAG: Return [<<Rem>>]
+ /// CHECK-START: long Main.Rem0(long) constant_folding (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:j\d+>> LongConstant 0
+ /// CHECK-DAG: <<DivZeroCheck:j\d+>> DivZeroCheck [<<Arg>>]
+ /// CHECK-DAG: <<Rem:j\d+>> Rem [<<Const0>>,<<DivZeroCheck>>]
+ /// CHECK-DAG: Return [<<Rem>>]
- // CHECK-START: long Main.Rem0(long) constant_folding (after)
- // CHECK-DAG: <<Const0:j\d+>> LongConstant 0
- // CHECK-NOT: Rem
- // CHECK-DAG: Return [<<Const0>>]
+ /// CHECK-START: long Main.Rem0(long) constant_folding (after)
+ /// CHECK-DAG: <<Const0:j\d+>> LongConstant 0
+ /// CHECK-NOT: Rem
+ /// CHECK-DAG: Return [<<Const0>>]
public static long Rem0(long arg) {
return 0 % arg;
}
- // CHECK-START: int Main.Rem1(int) constant_folding (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: <<Rem:i\d+>> Rem [<<Arg>>,<<Const1>>]
- // CHECK-DAG: Return [<<Rem>>]
+ /// CHECK-START: int Main.Rem1(int) constant_folding (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<Rem:i\d+>> Rem [<<Arg>>,<<Const1>>]
+ /// CHECK-DAG: Return [<<Rem>>]
- // CHECK-START: int Main.Rem1(int) constant_folding (after)
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-NOT: Rem
- // CHECK-DAG: Return [<<Const0>>]
+ /// CHECK-START: int Main.Rem1(int) constant_folding (after)
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-NOT: Rem
+ /// CHECK-DAG: Return [<<Const0>>]
public static int Rem1(int arg) {
return arg % 1;
}
- // CHECK-START: long Main.RemN1(long) constant_folding (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<ConstN1:j\d+>> LongConstant -1
- // CHECK-DAG: <<DivZeroCheck:j\d+>> DivZeroCheck [<<ConstN1>>]
- // CHECK-DAG: <<Rem:j\d+>> Rem [<<Arg>>,<<DivZeroCheck>>]
- // CHECK-DAG: Return [<<Rem>>]
+ /// CHECK-START: long Main.RemN1(long) constant_folding (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstN1:j\d+>> LongConstant -1
+ /// CHECK-DAG: <<DivZeroCheck:j\d+>> DivZeroCheck [<<ConstN1>>]
+ /// CHECK-DAG: <<Rem:j\d+>> Rem [<<Arg>>,<<DivZeroCheck>>]
+ /// CHECK-DAG: Return [<<Rem>>]
- // CHECK-START: long Main.RemN1(long) constant_folding (after)
- // CHECK-DAG: <<Const0:j\d+>> LongConstant 0
- // CHECK-NOT: Rem
- // CHECK-DAG: Return [<<Const0>>]
+ /// CHECK-START: long Main.RemN1(long) constant_folding (after)
+ /// CHECK-DAG: <<Const0:j\d+>> LongConstant 0
+ /// CHECK-NOT: Rem
+ /// CHECK-DAG: Return [<<Const0>>]
public static long RemN1(long arg) {
return arg % -1;
}
- // CHECK-START: int Main.Shl0(int) constant_folding (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Shl:i\d+>> Shl [<<Const0>>,<<Arg>>]
- // CHECK-DAG: Return [<<Shl>>]
+ /// CHECK-START: int Main.Shl0(int) constant_folding (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Shl:i\d+>> Shl [<<Const0>>,<<Arg>>]
+ /// CHECK-DAG: Return [<<Shl>>]
- // CHECK-START: int Main.Shl0(int) constant_folding (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-NOT: Shl
- // CHECK-DAG: Return [<<Const0>>]
+ /// CHECK-START: int Main.Shl0(int) constant_folding (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-NOT: Shl
+ /// CHECK-DAG: Return [<<Const0>>]
public static int Shl0(int arg) {
return 0 << arg;
}
- // CHECK-START: long Main.Shr0(int) constant_folding (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:j\d+>> LongConstant 0
- // CHECK-DAG: <<Shr:j\d+>> Shr [<<Const0>>,<<Arg>>]
- // CHECK-DAG: Return [<<Shr>>]
+ /// CHECK-START: long Main.Shr0(int) constant_folding (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:j\d+>> LongConstant 0
+ /// CHECK-DAG: <<Shr:j\d+>> Shr [<<Const0>>,<<Arg>>]
+ /// CHECK-DAG: Return [<<Shr>>]
- // CHECK-START: long Main.Shr0(int) constant_folding (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:j\d+>> LongConstant 0
- // CHECK-NOT: Shr
- // CHECK-DAG: Return [<<Const0>>]
+ /// CHECK-START: long Main.Shr0(int) constant_folding (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:j\d+>> LongConstant 0
+ /// CHECK-NOT: Shr
+ /// CHECK-DAG: Return [<<Const0>>]
public static long Shr0(int arg) {
return (long)0 >> arg;
}
- // CHECK-START: long Main.SubSameLong(long) constant_folding (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Sub:j\d+>> Sub [<<Arg>>,<<Arg>>]
- // CHECK-DAG: Return [<<Sub>>]
+ /// CHECK-START: long Main.SubSameLong(long) constant_folding (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Sub:j\d+>> Sub [<<Arg>>,<<Arg>>]
+ /// CHECK-DAG: Return [<<Sub>>]
- // CHECK-START: long Main.SubSameLong(long) constant_folding (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Const0:j\d+>> LongConstant 0
- // CHECK-NOT: Sub
- // CHECK-DAG: Return [<<Const0>>]
+ /// CHECK-START: long Main.SubSameLong(long) constant_folding (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:j\d+>> LongConstant 0
+ /// CHECK-NOT: Sub
+ /// CHECK-DAG: Return [<<Const0>>]
public static long SubSameLong(long arg) {
return arg - arg;
}
- // CHECK-START: int Main.UShr0(int) constant_folding (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<UShr:i\d+>> UShr [<<Const0>>,<<Arg>>]
- // CHECK-DAG: Return [<<UShr>>]
+ /// CHECK-START: int Main.UShr0(int) constant_folding (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<UShr:i\d+>> UShr [<<Const0>>,<<Arg>>]
+ /// CHECK-DAG: Return [<<UShr>>]
- // CHECK-START: int Main.UShr0(int) constant_folding (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-NOT: UShr
- // CHECK-DAG: Return [<<Const0>>]
+ /// CHECK-START: int Main.UShr0(int) constant_folding (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-NOT: UShr
+ /// CHECK-DAG: Return [<<Const0>>]
public static int UShr0(int arg) {
return 0 >>> arg;
}
- // CHECK-START: int Main.XorSameInt(int) constant_folding (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Xor:i\d+>> Xor [<<Arg>>,<<Arg>>]
- // CHECK-DAG: Return [<<Xor>>]
+ /// CHECK-START: int Main.XorSameInt(int) constant_folding (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Xor:i\d+>> Xor [<<Arg>>,<<Arg>>]
+ /// CHECK-DAG: Return [<<Xor>>]
- // CHECK-START: int Main.XorSameInt(int) constant_folding (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-NOT: Xor
- // CHECK-DAG: Return [<<Const0>>]
+ /// CHECK-START: int Main.XorSameInt(int) constant_folding (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-NOT: Xor
+ /// CHECK-DAG: Return [<<Const0>>]
public static int XorSameInt(int arg) {
return arg ^ arg;
}
- // CHECK-START: boolean Main.CmpFloatGreaterThanNaN(float) constant_folding (before)
- // CHECK-DAG: <<Arg:f\d+>> ParameterValue
- // CHECK-DAG: <<ConstNan:f\d+>> FloatConstant nan
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: IntConstant 1
- // CHECK-DAG: <<Cmp:i\d+>> Compare [<<Arg>>,<<ConstNan>>]
- // CHECK-DAG: <<Le:z\d+>> LessThanOrEqual [<<Cmp>>,<<Const0>>]
- // CHECK-DAG: If [<<Le>>]
+ /// CHECK-START: boolean Main.CmpFloatGreaterThanNaN(float) constant_folding (before)
+ /// CHECK-DAG: <<Arg:f\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstNan:f\d+>> FloatConstant nan
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: IntConstant 1
+ /// CHECK-DAG: <<Cmp:i\d+>> Compare [<<Arg>>,<<ConstNan>>]
+ /// CHECK-DAG: <<Le:z\d+>> LessThanOrEqual [<<Cmp>>,<<Const0>>]
+ /// CHECK-DAG: If [<<Le>>]
- // CHECK-START: boolean Main.CmpFloatGreaterThanNaN(float) constant_folding (after)
- // CHECK-DAG: ParameterValue
- // CHECK-DAG: FloatConstant nan
- // CHECK-DAG: IntConstant 0
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: If [<<Const1>>]
+ /// CHECK-START: boolean Main.CmpFloatGreaterThanNaN(float) constant_folding (after)
+ /// CHECK-DAG: ParameterValue
+ /// CHECK-DAG: FloatConstant nan
+ /// CHECK-DAG: IntConstant 0
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: If [<<Const1>>]
- // CHECK-START: boolean Main.CmpFloatGreaterThanNaN(float) constant_folding (after)
- // CHECK-NOT: Compare
- // CHECK-NOT: LessThanOrEqual
+ /// CHECK-START: boolean Main.CmpFloatGreaterThanNaN(float) constant_folding (after)
+ /// CHECK-NOT: Compare
+ /// CHECK-NOT: LessThanOrEqual
public static boolean CmpFloatGreaterThanNaN(float arg) {
return arg > Float.NaN;
}
- // CHECK-START: boolean Main.CmpDoubleLessThanNaN(double) constant_folding (before)
- // CHECK-DAG: <<Arg:d\d+>> ParameterValue
- // CHECK-DAG: <<ConstNan:d\d+>> DoubleConstant nan
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: IntConstant 1
- // CHECK-DAG: <<Cmp:i\d+>> Compare [<<Arg>>,<<ConstNan>>]
- // CHECK-DAG: <<Ge:z\d+>> GreaterThanOrEqual [<<Cmp>>,<<Const0>>]
- // CHECK-DAG: If [<<Ge>>]
+ /// CHECK-START: boolean Main.CmpDoubleLessThanNaN(double) constant_folding (before)
+ /// CHECK-DAG: <<Arg:d\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstNan:d\d+>> DoubleConstant nan
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: IntConstant 1
+ /// CHECK-DAG: <<Cmp:i\d+>> Compare [<<Arg>>,<<ConstNan>>]
+ /// CHECK-DAG: <<Ge:z\d+>> GreaterThanOrEqual [<<Cmp>>,<<Const0>>]
+ /// CHECK-DAG: If [<<Ge>>]
- // CHECK-START: boolean Main.CmpDoubleLessThanNaN(double) constant_folding (after)
- // CHECK-DAG: ParameterValue
- // CHECK-DAG: DoubleConstant nan
- // CHECK-DAG: IntConstant 0
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: If [<<Const1>>]
+ /// CHECK-START: boolean Main.CmpDoubleLessThanNaN(double) constant_folding (after)
+ /// CHECK-DAG: ParameterValue
+ /// CHECK-DAG: DoubleConstant nan
+ /// CHECK-DAG: IntConstant 0
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: If [<<Const1>>]
- // CHECK-START: boolean Main.CmpDoubleLessThanNaN(double) constant_folding (after)
- // CHECK-NOT: Compare
- // CHECK-NOT: GreaterThanOrEqual
+ /// CHECK-START: boolean Main.CmpDoubleLessThanNaN(double) constant_folding (after)
+ /// CHECK-NOT: Compare
+ /// CHECK-NOT: GreaterThanOrEqual
public static boolean CmpDoubleLessThanNaN(double arg) {
return arg < Double.NaN;
}
- // CHECK-START: int Main.ReturnInt33() constant_folding (before)
- // CHECK-DAG: <<Const33:j\d+>> LongConstant 33
- // CHECK-DAG: <<Convert:i\d+>> TypeConversion [<<Const33>>]
- // CHECK-DAG: Return [<<Convert>>]
+ /// CHECK-START: int Main.ReturnInt33() constant_folding (before)
+ /// CHECK-DAG: <<Const33:j\d+>> LongConstant 33
+ /// CHECK-DAG: <<Convert:i\d+>> TypeConversion [<<Const33>>]
+ /// CHECK-DAG: Return [<<Convert>>]
- // CHECK-START: int Main.ReturnInt33() constant_folding (after)
- // CHECK-DAG: <<Const33:i\d+>> IntConstant 33
- // CHECK-DAG: Return [<<Const33>>]
+ /// CHECK-START: int Main.ReturnInt33() constant_folding (after)
+ /// CHECK-DAG: <<Const33:i\d+>> IntConstant 33
+ /// CHECK-DAG: Return [<<Const33>>]
public static int ReturnInt33() {
long imm = 33L;
return (int) imm;
}
- // CHECK-START: int Main.ReturnIntMax() constant_folding (before)
- // CHECK-DAG: <<ConstMax:f\d+>> FloatConstant 1e+34
- // CHECK-DAG: <<Convert:i\d+>> TypeConversion [<<ConstMax>>]
- // CHECK-DAG: Return [<<Convert>>]
+ /// CHECK-START: int Main.ReturnIntMax() constant_folding (before)
+ /// CHECK-DAG: <<ConstMax:f\d+>> FloatConstant 1e+34
+ /// CHECK-DAG: <<Convert:i\d+>> TypeConversion [<<ConstMax>>]
+ /// CHECK-DAG: Return [<<Convert>>]
- // CHECK-START: int Main.ReturnIntMax() constant_folding (after)
- // CHECK-DAG: <<ConstMax:i\d+>> IntConstant 2147483647
- // CHECK-DAG: Return [<<ConstMax>>]
+ /// CHECK-START: int Main.ReturnIntMax() constant_folding (after)
+ /// CHECK-DAG: <<ConstMax:i\d+>> IntConstant 2147483647
+ /// CHECK-DAG: Return [<<ConstMax>>]
public static int ReturnIntMax() {
float imm = 1.0e34f;
return (int) imm;
}
- // CHECK-START: int Main.ReturnInt0() constant_folding (before)
- // CHECK-DAG: <<ConstNaN:d\d+>> DoubleConstant nan
- // CHECK-DAG: <<Convert:i\d+>> TypeConversion [<<ConstNaN>>]
- // CHECK-DAG: Return [<<Convert>>]
+ /// CHECK-START: int Main.ReturnInt0() constant_folding (before)
+ /// CHECK-DAG: <<ConstNaN:d\d+>> DoubleConstant nan
+ /// CHECK-DAG: <<Convert:i\d+>> TypeConversion [<<ConstNaN>>]
+ /// CHECK-DAG: Return [<<Convert>>]
- // CHECK-START: int Main.ReturnInt0() constant_folding (after)
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: Return [<<Const0>>]
+ /// CHECK-START: int Main.ReturnInt0() constant_folding (after)
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: Return [<<Const0>>]
public static int ReturnInt0() {
double imm = Double.NaN;
return (int) imm;
}
- // CHECK-START: long Main.ReturnLong33() constant_folding (before)
- // CHECK-DAG: <<Const33:i\d+>> IntConstant 33
- // CHECK-DAG: <<Convert:j\d+>> TypeConversion [<<Const33>>]
- // CHECK-DAG: Return [<<Convert>>]
+ /// CHECK-START: long Main.ReturnLong33() constant_folding (before)
+ /// CHECK-DAG: <<Const33:i\d+>> IntConstant 33
+ /// CHECK-DAG: <<Convert:j\d+>> TypeConversion [<<Const33>>]
+ /// CHECK-DAG: Return [<<Convert>>]
- // CHECK-START: long Main.ReturnLong33() constant_folding (after)
- // CHECK-DAG: <<Const33:j\d+>> LongConstant 33
- // CHECK-DAG: Return [<<Const33>>]
+ /// CHECK-START: long Main.ReturnLong33() constant_folding (after)
+ /// CHECK-DAG: <<Const33:j\d+>> LongConstant 33
+ /// CHECK-DAG: Return [<<Const33>>]
public static long ReturnLong33() {
int imm = 33;
return (long) imm;
}
- // CHECK-START: long Main.ReturnLong34() constant_folding (before)
- // CHECK-DAG: <<Const34:f\d+>> FloatConstant 34
- // CHECK-DAG: <<Convert:j\d+>> TypeConversion [<<Const34>>]
- // CHECK-DAG: Return [<<Convert>>]
+ /// CHECK-START: long Main.ReturnLong34() constant_folding (before)
+ /// CHECK-DAG: <<Const34:f\d+>> FloatConstant 34
+ /// CHECK-DAG: <<Convert:j\d+>> TypeConversion [<<Const34>>]
+ /// CHECK-DAG: Return [<<Convert>>]
- // CHECK-START: long Main.ReturnLong34() constant_folding (after)
- // CHECK-DAG: <<Const34:j\d+>> LongConstant 34
- // CHECK-DAG: Return [<<Const34>>]
+ /// CHECK-START: long Main.ReturnLong34() constant_folding (after)
+ /// CHECK-DAG: <<Const34:j\d+>> LongConstant 34
+ /// CHECK-DAG: Return [<<Const34>>]
public static long ReturnLong34() {
float imm = 34.0f;
return (long) imm;
}
- // CHECK-START: long Main.ReturnLong0() constant_folding (before)
- // CHECK-DAG: <<ConstNaN:d\d+>> DoubleConstant nan
- // CHECK-DAG: <<Convert:j\d+>> TypeConversion [<<ConstNaN>>]
- // CHECK-DAG: Return [<<Convert>>]
+ /// CHECK-START: long Main.ReturnLong0() constant_folding (before)
+ /// CHECK-DAG: <<ConstNaN:d\d+>> DoubleConstant nan
+ /// CHECK-DAG: <<Convert:j\d+>> TypeConversion [<<ConstNaN>>]
+ /// CHECK-DAG: Return [<<Convert>>]
- // CHECK-START: long Main.ReturnLong0() constant_folding (after)
- // CHECK-DAG: <<Const0:j\d+>> LongConstant 0
- // CHECK-DAG: Return [<<Const0>>]
+ /// CHECK-START: long Main.ReturnLong0() constant_folding (after)
+ /// CHECK-DAG: <<Const0:j\d+>> LongConstant 0
+ /// CHECK-DAG: Return [<<Const0>>]
public static long ReturnLong0() {
double imm = -Double.NaN;
return (long) imm;
}
- // CHECK-START: float Main.ReturnFloat33() constant_folding (before)
- // CHECK-DAG: <<Const33:i\d+>> IntConstant 33
- // CHECK-DAG: <<Convert:f\d+>> TypeConversion [<<Const33>>]
- // CHECK-DAG: Return [<<Convert>>]
+ /// CHECK-START: float Main.ReturnFloat33() constant_folding (before)
+ /// CHECK-DAG: <<Const33:i\d+>> IntConstant 33
+ /// CHECK-DAG: <<Convert:f\d+>> TypeConversion [<<Const33>>]
+ /// CHECK-DAG: Return [<<Convert>>]
- // CHECK-START: float Main.ReturnFloat33() constant_folding (after)
- // CHECK-DAG: <<Const33:f\d+>> FloatConstant 33
- // CHECK-DAG: Return [<<Const33>>]
+ /// CHECK-START: float Main.ReturnFloat33() constant_folding (after)
+ /// CHECK-DAG: <<Const33:f\d+>> FloatConstant 33
+ /// CHECK-DAG: Return [<<Const33>>]
public static float ReturnFloat33() {
int imm = 33;
return (float) imm;
}
- // CHECK-START: float Main.ReturnFloat34() constant_folding (before)
- // CHECK-DAG: <<Const34:j\d+>> LongConstant 34
- // CHECK-DAG: <<Convert:f\d+>> TypeConversion [<<Const34>>]
- // CHECK-DAG: Return [<<Convert>>]
+ /// CHECK-START: float Main.ReturnFloat34() constant_folding (before)
+ /// CHECK-DAG: <<Const34:j\d+>> LongConstant 34
+ /// CHECK-DAG: <<Convert:f\d+>> TypeConversion [<<Const34>>]
+ /// CHECK-DAG: Return [<<Convert>>]
- // CHECK-START: float Main.ReturnFloat34() constant_folding (after)
- // CHECK-DAG: <<Const34:f\d+>> FloatConstant 34
- // CHECK-DAG: Return [<<Const34>>]
+ /// CHECK-START: float Main.ReturnFloat34() constant_folding (after)
+ /// CHECK-DAG: <<Const34:f\d+>> FloatConstant 34
+ /// CHECK-DAG: Return [<<Const34>>]
public static float ReturnFloat34() {
long imm = 34L;
return (float) imm;
}
- // CHECK-START: float Main.ReturnFloat99P25() constant_folding (before)
- // CHECK-DAG: <<Const:d\d+>> DoubleConstant 99.25
- // CHECK-DAG: <<Convert:f\d+>> TypeConversion [<<Const>>]
- // CHECK-DAG: Return [<<Convert>>]
+ /// CHECK-START: float Main.ReturnFloat99P25() constant_folding (before)
+ /// CHECK-DAG: <<Const:d\d+>> DoubleConstant 99.25
+ /// CHECK-DAG: <<Convert:f\d+>> TypeConversion [<<Const>>]
+ /// CHECK-DAG: Return [<<Convert>>]
- // CHECK-START: float Main.ReturnFloat99P25() constant_folding (after)
- // CHECK-DAG: <<Const:f\d+>> FloatConstant 99.25
- // CHECK-DAG: Return [<<Const>>]
+ /// CHECK-START: float Main.ReturnFloat99P25() constant_folding (after)
+ /// CHECK-DAG: <<Const:f\d+>> FloatConstant 99.25
+ /// CHECK-DAG: Return [<<Const>>]
public static float ReturnFloat99P25() {
double imm = 99.25;
return (float) imm;
}
- // CHECK-START: double Main.ReturnDouble33() constant_folding (before)
- // CHECK-DAG: <<Const33:i\d+>> IntConstant 33
- // CHECK-DAG: <<Convert:d\d+>> TypeConversion [<<Const33>>]
- // CHECK-DAG: Return [<<Convert>>]
+ /// CHECK-START: double Main.ReturnDouble33() constant_folding (before)
+ /// CHECK-DAG: <<Const33:i\d+>> IntConstant 33
+ /// CHECK-DAG: <<Convert:d\d+>> TypeConversion [<<Const33>>]
+ /// CHECK-DAG: Return [<<Convert>>]
- // CHECK-START: double Main.ReturnDouble33() constant_folding (after)
- // CHECK-DAG: <<Const33:d\d+>> DoubleConstant 33
- // CHECK-DAG: Return [<<Const33>>]
+ /// CHECK-START: double Main.ReturnDouble33() constant_folding (after)
+ /// CHECK-DAG: <<Const33:d\d+>> DoubleConstant 33
+ /// CHECK-DAG: Return [<<Const33>>]
public static double ReturnDouble33() {
int imm = 33;
return (double) imm;
}
- // CHECK-START: double Main.ReturnDouble34() constant_folding (before)
- // CHECK-DAG: <<Const34:j\d+>> LongConstant 34
- // CHECK-DAG: <<Convert:d\d+>> TypeConversion [<<Const34>>]
- // CHECK-DAG: Return [<<Convert>>]
+ /// CHECK-START: double Main.ReturnDouble34() constant_folding (before)
+ /// CHECK-DAG: <<Const34:j\d+>> LongConstant 34
+ /// CHECK-DAG: <<Convert:d\d+>> TypeConversion [<<Const34>>]
+ /// CHECK-DAG: Return [<<Convert>>]
- // CHECK-START: double Main.ReturnDouble34() constant_folding (after)
- // CHECK-DAG: <<Const34:d\d+>> DoubleConstant 34
- // CHECK-DAG: Return [<<Const34>>]
+ /// CHECK-START: double Main.ReturnDouble34() constant_folding (after)
+ /// CHECK-DAG: <<Const34:d\d+>> DoubleConstant 34
+ /// CHECK-DAG: Return [<<Const34>>]
public static double ReturnDouble34() {
long imm = 34L;
return (double) imm;
}
- // CHECK-START: double Main.ReturnDouble99P25() constant_folding (before)
- // CHECK-DAG: <<Const:f\d+>> FloatConstant 99.25
- // CHECK-DAG: <<Convert:d\d+>> TypeConversion [<<Const>>]
- // CHECK-DAG: Return [<<Convert>>]
+ /// CHECK-START: double Main.ReturnDouble99P25() constant_folding (before)
+ /// CHECK-DAG: <<Const:f\d+>> FloatConstant 99.25
+ /// CHECK-DAG: <<Convert:d\d+>> TypeConversion [<<Const>>]
+ /// CHECK-DAG: Return [<<Convert>>]
- // CHECK-START: double Main.ReturnDouble99P25() constant_folding (after)
- // CHECK-DAG: <<Const:d\d+>> DoubleConstant 99.25
- // CHECK-DAG: Return [<<Const>>]
+ /// CHECK-START: double Main.ReturnDouble99P25() constant_folding (after)
+ /// CHECK-DAG: <<Const:d\d+>> DoubleConstant 99.25
+ /// CHECK-DAG: Return [<<Const>>]
public static double ReturnDouble99P25() {
float imm = 99.25f;
diff --git a/test/444-checker-nce/src/Main.java b/test/444-checker-nce/src/Main.java
index 501d79c..6ac0cad 100644
--- a/test/444-checker-nce/src/Main.java
+++ b/test/444-checker-nce/src/Main.java
@@ -16,63 +16,63 @@
public class Main {
- // CHECK-START: Main Main.keepTest(Main) instruction_simplifier_after_types (before)
- // CHECK: NullCheck
- // CHECK: InvokeStaticOrDirect
+ /// CHECK-START: Main Main.keepTest(Main) instruction_simplifier_after_types (before)
+ /// CHECK: NullCheck
+ /// CHECK: InvokeStaticOrDirect
- // CHECK-START: Main Main.keepTest(Main) instruction_simplifier_after_types (after)
- // CHECK: NullCheck
- // CHECK: InvokeStaticOrDirect
+ /// CHECK-START: Main Main.keepTest(Main) instruction_simplifier_after_types (after)
+ /// CHECK: NullCheck
+ /// CHECK: InvokeStaticOrDirect
public Main keepTest(Main m) {
return m.g();
}
- // CHECK-START: Main Main.thisTest() instruction_simplifier (before)
- // CHECK: NullCheck
- // CHECK: InvokeStaticOrDirect
+ /// CHECK-START: Main Main.thisTest() instruction_simplifier (before)
+ /// CHECK: NullCheck
+ /// CHECK: InvokeStaticOrDirect
- // CHECK-START: Main Main.thisTest() instruction_simplifier (after)
- // CHECK-NOT: NullCheck
- // CHECK: InvokeStaticOrDirect
+ /// CHECK-START: Main Main.thisTest() instruction_simplifier (after)
+ /// CHECK-NOT: NullCheck
+ /// CHECK: InvokeStaticOrDirect
public Main thisTest() {
return g();
}
- // CHECK-START: Main Main.newInstanceRemoveTest() instruction_simplifier (before)
- // CHECK: NewInstance
- // CHECK: NullCheck
- // CHECK: InvokeStaticOrDirect
- // CHECK: NullCheck
- // CHECK: InvokeStaticOrDirect
+ /// CHECK-START: Main Main.newInstanceRemoveTest() instruction_simplifier (before)
+ /// CHECK: NewInstance
+ /// CHECK: NullCheck
+ /// CHECK: InvokeStaticOrDirect
+ /// CHECK: NullCheck
+ /// CHECK: InvokeStaticOrDirect
- // CHECK-START: Main Main.newInstanceRemoveTest() instruction_simplifier (after)
- // CHECK-NOT: NullCheck
+ /// CHECK-START: Main Main.newInstanceRemoveTest() instruction_simplifier (after)
+ /// CHECK-NOT: NullCheck
public Main newInstanceRemoveTest() {
Main m = new Main();
return m.g();
}
- // CHECK-START: Main Main.newArrayRemoveTest() instruction_simplifier (before)
- // CHECK: NewArray
- // CHECK: NullCheck
- // CHECK: ArrayGet
+ /// CHECK-START: Main Main.newArrayRemoveTest() instruction_simplifier (before)
+ /// CHECK: NewArray
+ /// CHECK: NullCheck
+ /// CHECK: ArrayGet
- // CHECK-START: Main Main.newArrayRemoveTest() instruction_simplifier (after)
- // CHECK: NewArray
- // CHECK-NOT: NullCheck
- // CHECK: ArrayGet
+ /// CHECK-START: Main Main.newArrayRemoveTest() instruction_simplifier (after)
+ /// CHECK: NewArray
+ /// CHECK-NOT: NullCheck
+ /// CHECK: ArrayGet
public Main newArrayRemoveTest() {
Main[] ms = new Main[1];
return ms[0];
}
- // CHECK-START: Main Main.ifRemoveTest(boolean) instruction_simplifier_after_types (before)
- // CHECK: NewInstance
- // CHECK: NullCheck
+ /// CHECK-START: Main Main.ifRemoveTest(boolean) instruction_simplifier_after_types (before)
+ /// CHECK: NewInstance
+ /// CHECK: NullCheck
- // CHECK-START: Main Main.ifRemoveTest(boolean) instruction_simplifier_after_types (after)
- // CHECK: NewInstance
- // CHECK-NOT: NullCheck
+ /// CHECK-START: Main Main.ifRemoveTest(boolean) instruction_simplifier_after_types (after)
+ /// CHECK: NewInstance
+ /// CHECK-NOT: NullCheck
public Main ifRemoveTest(boolean flag) {
Main m = null;
if (flag) {
@@ -83,13 +83,13 @@
return m.g();
}
- // CHECK-START: Main Main.ifKeepTest(boolean) instruction_simplifier_after_types (before)
- // CHECK: NewInstance
- // CHECK: NullCheck
+ /// CHECK-START: Main Main.ifKeepTest(boolean) instruction_simplifier_after_types (before)
+ /// CHECK: NewInstance
+ /// CHECK: NullCheck
- // CHECK-START: Main Main.ifKeepTest(boolean) instruction_simplifier_after_types (after)
- // CHECK: NewInstance
- // CHECK: NullCheck
+ /// CHECK-START: Main Main.ifKeepTest(boolean) instruction_simplifier_after_types (after)
+ /// CHECK: NewInstance
+ /// CHECK: NullCheck
public Main ifKeepTest(boolean flag) {
Main m = null;
if (flag) {
@@ -98,11 +98,11 @@
return m.g();
}
- // CHECK-START: Main Main.forRemoveTest(int) instruction_simplifier_after_types (before)
- // CHECK: NullCheck
+ /// CHECK-START: Main Main.forRemoveTest(int) instruction_simplifier_after_types (before)
+ /// CHECK: NullCheck
- // CHECK-START: Main Main.forRemoveTest(int) instruction_simplifier_after_types (after)
- // CHECK-NOT: NullCheck
+ /// CHECK-START: Main Main.forRemoveTest(int) instruction_simplifier_after_types (after)
+ /// CHECK-NOT: NullCheck
public Main forRemoveTest(int count) {
Main a = new Main();
Main m = new Main();
@@ -114,11 +114,11 @@
return m.g();
}
- // CHECK-START: Main Main.forKeepTest(int) instruction_simplifier_after_types (before)
- // CHECK: NullCheck
+ /// CHECK-START: Main Main.forKeepTest(int) instruction_simplifier_after_types (before)
+ /// CHECK: NullCheck
- // CHECK-START: Main Main.forKeepTest(int) instruction_simplifier_after_types (after)
- // CHECK: NullCheck
+ /// CHECK-START: Main Main.forKeepTest(int) instruction_simplifier_after_types (after)
+ /// CHECK: NullCheck
public Main forKeepTest(int count) {
Main a = new Main();
Main m = new Main();
@@ -132,11 +132,11 @@
return m.g();
}
- // CHECK-START: Main Main.phiFlowRemoveTest(int) instruction_simplifier_after_types (before)
- // CHECK: NullCheck
+ /// CHECK-START: Main Main.phiFlowRemoveTest(int) instruction_simplifier_after_types (before)
+ /// CHECK: NullCheck
- // CHECK-START: Main Main.phiFlowRemoveTest(int) instruction_simplifier_after_types (after)
- // CHECK-NOT: NullCheck
+ /// CHECK-START: Main Main.phiFlowRemoveTest(int) instruction_simplifier_after_types (after)
+ /// CHECK-NOT: NullCheck
public Main phiFlowRemoveTest(int count) {
Main a = new Main();
Main m = new Main();
@@ -154,11 +154,11 @@
return n.g();
}
- // CHECK-START: Main Main.phiFlowKeepTest(int) instruction_simplifier_after_types (before)
- // CHECK: NullCheck
+ /// CHECK-START: Main Main.phiFlowKeepTest(int) instruction_simplifier_after_types (before)
+ /// CHECK: NullCheck
- // CHECK-START: Main Main.phiFlowKeepTest(int) instruction_simplifier_after_types (after)
- // CHECK: NullCheck
+ /// CHECK-START: Main Main.phiFlowKeepTest(int) instruction_simplifier_after_types (after)
+ /// CHECK: NullCheck
public Main phiFlowKeepTest(int count) {
Main a = new Main();
Main m = new Main();
@@ -178,11 +178,11 @@
return n.g();
}
- // CHECK-START: Main Main.scopeRemoveTest(int, Main) instruction_simplifier (before)
- // CHECK: NullCheck
+ /// CHECK-START: Main Main.scopeRemoveTest(int, Main) instruction_simplifier (before)
+ /// CHECK: NullCheck
- // CHECK-START: Main Main.scopeRemoveTest(int, Main) instruction_simplifier (after)
- // CHECK-NOT: NullCheck
+ /// CHECK-START: Main Main.scopeRemoveTest(int, Main) instruction_simplifier (after)
+ /// CHECK-NOT: NullCheck
public Main scopeRemoveTest(int count, Main a) {
Main m = null;
for (int i = 0; i < count; i++) {
@@ -196,11 +196,11 @@
return m;
}
- // CHECK-START: Main Main.scopeKeepTest(int, Main) instruction_simplifier_after_types (before)
- // CHECK: NullCheck
+ /// CHECK-START: Main Main.scopeKeepTest(int, Main) instruction_simplifier_after_types (before)
+ /// CHECK: NullCheck
- // CHECK-START: Main Main.scopeKeepTest(int, Main) instruction_simplifier_after_types (after)
- // CHECK: NullCheck
+ /// CHECK-START: Main Main.scopeKeepTest(int, Main) instruction_simplifier_after_types (after)
+ /// CHECK: NullCheck
public Main scopeKeepTest(int count, Main a) {
Main m = new Main();
for (int i = 0; i < count; i++) {
@@ -214,11 +214,11 @@
return m;
}
- // CHECK-START: Main Main.scopeIfNotNullRemove(Main) instruction_simplifier_after_types (before)
- // CHECK: NullCheck
+ /// CHECK-START: Main Main.scopeIfNotNullRemove(Main) instruction_simplifier_after_types (before)
+ /// CHECK: NullCheck
- // CHECK-START: Main Main.scopeIfNotNullRemove(Main) instruction_simplifier_after_types (after)
- // CHECK-NOT: NullCheck
+ /// CHECK-START: Main Main.scopeIfNotNullRemove(Main) instruction_simplifier_after_types (after)
+ /// CHECK-NOT: NullCheck
public Main scopeIfNotNullRemove(Main m) {
if (m != null) {
return m.g();
@@ -226,11 +226,11 @@
return m;
}
- // CHECK-START: Main Main.scopeIfKeep(Main) instruction_simplifier_after_types (before)
- // CHECK: NullCheck
+ /// CHECK-START: Main Main.scopeIfKeep(Main) instruction_simplifier_after_types (before)
+ /// CHECK: NullCheck
- // CHECK-START: Main Main.scopeIfKeep(Main) instruction_simplifier_after_types (after)
- // CHECK: NullCheck
+ /// CHECK-START: Main Main.scopeIfKeep(Main) instruction_simplifier_after_types (after)
+ /// CHECK: NullCheck
public Main scopeIfKeep(Main m) {
if (m == null) {
m = new Main();
@@ -258,12 +258,12 @@
class ListElement {
private ListElement next;
- // CHECK-START: boolean ListElement.isShorter(ListElement, ListElement) instruction_simplifier_after_types (before)
- // CHECK: NullCheck
- // CHECK: NullCheck
+ /// CHECK-START: boolean ListElement.isShorter(ListElement, ListElement) instruction_simplifier_after_types (before)
+ /// CHECK: NullCheck
+ /// CHECK: NullCheck
- // CHECK-START: boolean ListElement.isShorter(ListElement, ListElement) instruction_simplifier_after_types (after)
- // CHECK-NOT: NullCheck
+ /// CHECK-START: boolean ListElement.isShorter(ListElement, ListElement) instruction_simplifier_after_types (after)
+ /// CHECK-NOT: NullCheck
static boolean isShorter(ListElement x, ListElement y) {
ListElement xTail = x;
ListElement yTail = y;
diff --git a/test/445-checker-licm/src/Main.java b/test/445-checker-licm/src/Main.java
index 96918d3..42f9a11 100644
--- a/test/445-checker-licm/src/Main.java
+++ b/test/445-checker-licm/src/Main.java
@@ -16,14 +16,14 @@
public class Main {
- // CHECK-START: int Main.div() licm (before)
- // CHECK-DAG: Div loop:{{B\d+}}
+ /// CHECK-START: int Main.div() licm (before)
+ /// CHECK-DAG: Div loop:{{B\d+}}
- // CHECK-START: int Main.div() licm (after)
- // CHECK-NOT: Div loop:{{B\d+}}
+ /// CHECK-START: int Main.div() licm (after)
+ /// CHECK-NOT: Div loop:{{B\d+}}
- // CHECK-START: int Main.div() licm (after)
- // CHECK-DAG: Div loop:none
+ /// CHECK-START: int Main.div() licm (after)
+ /// CHECK-DAG: Div loop:none
public static int div() {
int result = 0;
@@ -33,14 +33,14 @@
return result;
}
- // CHECK-START: int Main.innerDiv() licm (before)
- // CHECK-DAG: Div loop:{{B\d+}}
+ /// CHECK-START: int Main.innerDiv() licm (before)
+ /// CHECK-DAG: Div loop:{{B\d+}}
- // CHECK-START: int Main.innerDiv() licm (after)
- // CHECK-NOT: Div loop:{{B\d+}}
+ /// CHECK-START: int Main.innerDiv() licm (after)
+ /// CHECK-NOT: Div loop:{{B\d+}}
- // CHECK-START: int Main.innerDiv() licm (after)
- // CHECK-DAG: Div loop:none
+ /// CHECK-START: int Main.innerDiv() licm (after)
+ /// CHECK-DAG: Div loop:none
public static int innerDiv() {
int result = 0;
@@ -52,11 +52,11 @@
return result;
}
- // CHECK-START: int Main.innerDiv2() licm (before)
- // CHECK-DAG: Mul loop:B4
+ /// CHECK-START: int Main.innerDiv2() licm (before)
+ /// CHECK-DAG: Mul loop:B4
- // CHECK-START: int Main.innerDiv2() licm (after)
- // CHECK-DAG: Mul loop:B2
+ /// CHECK-START: int Main.innerDiv2() licm (after)
+ /// CHECK-DAG: Mul loop:B2
public static int innerDiv2() {
int result = 0;
@@ -71,11 +71,11 @@
return result;
}
- // CHECK-START: int Main.innerDiv3(int, int) licm (before)
- // CHECK-DAG: Div loop:{{B\d+}}
+ /// CHECK-START: int Main.innerDiv3(int, int) licm (before)
+ /// CHECK-DAG: Div loop:{{B\d+}}
- // CHECK-START: int Main.innerDiv3(int, int) licm (after)
- // CHECK-DAG: Div loop:{{B\d+}}
+ /// CHECK-START: int Main.innerDiv3(int, int) licm (after)
+ /// CHECK-DAG: Div loop:{{B\d+}}
public static int innerDiv3(int a, int b) {
int result = 0;
@@ -87,17 +87,17 @@
return result;
}
- // CHECK-START: int Main.arrayLength(int[]) licm (before)
- // CHECK-DAG: <<NullCheck:l\d+>> NullCheck loop:{{B\d+}}
- // CHECK-DAG: ArrayLength [<<NullCheck>>] loop:{{B\d+}}
+ /// CHECK-START: int Main.arrayLength(int[]) licm (before)
+ /// CHECK-DAG: <<NullCheck:l\d+>> NullCheck loop:{{B\d+}}
+ /// CHECK-DAG: ArrayLength [<<NullCheck>>] loop:{{B\d+}}
- // CHECK-START: int Main.arrayLength(int[]) licm (after)
- // CHECK-NOT: NullCheck loop:{{B\d+}}
- // CHECK-NOT: ArrayLength loop:{{B\d+}}
+ /// CHECK-START: int Main.arrayLength(int[]) licm (after)
+ /// CHECK-NOT: NullCheck loop:{{B\d+}}
+ /// CHECK-NOT: ArrayLength loop:{{B\d+}}
- // CHECK-START: int Main.arrayLength(int[]) licm (after)
- // CHECK-DAG: <<NullCheck:l\d+>> NullCheck loop:none
- // CHECK-DAG: ArrayLength [<<NullCheck>>] loop:none
+ /// CHECK-START: int Main.arrayLength(int[]) licm (after)
+ /// CHECK-DAG: <<NullCheck:l\d+>> NullCheck loop:none
+ /// CHECK-DAG: ArrayLength [<<NullCheck>>] loop:none
public static int arrayLength(int[] array) {
int result = 0;
diff --git a/test/446-checker-inliner2/src/Main.java b/test/446-checker-inliner2/src/Main.java
index 9ed66d6..de00a09 100644
--- a/test/446-checker-inliner2/src/Main.java
+++ b/test/446-checker-inliner2/src/Main.java
@@ -16,16 +16,16 @@
public class Main {
- // CHECK-START: int Main.inlineInstanceCall(Main) inliner (before)
- // CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Invoke>>]
+ /// CHECK-START: int Main.inlineInstanceCall(Main) inliner (before)
+ /// CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Invoke>>]
- // CHECK-START: int Main.inlineInstanceCall(Main) inliner (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: int Main.inlineInstanceCall(Main) inliner (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
- // CHECK-START: int Main.inlineInstanceCall(Main) inliner (after)
- // CHECK-DAG: <<Field:i\d+>> InstanceFieldGet
- // CHECK-DAG: Return [<<Field>>]
+ /// CHECK-START: int Main.inlineInstanceCall(Main) inliner (after)
+ /// CHECK-DAG: <<Field:i\d+>> InstanceFieldGet
+ /// CHECK-DAG: Return [<<Field>>]
public static int inlineInstanceCall(Main m) {
return m.foo();
@@ -37,16 +37,16 @@
int field = 42;
- // CHECK-START: int Main.inlineNestedCall() inliner (before)
- // CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Invoke>>]
+ /// CHECK-START: int Main.inlineNestedCall() inliner (before)
+ /// CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Invoke>>]
- // CHECK-START: int Main.inlineNestedCall() inliner (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: int Main.inlineNestedCall() inliner (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
- // CHECK-START: int Main.inlineNestedCall() inliner (after)
- // CHECK-DAG: <<Const38:i\d+>> IntConstant 38
- // CHECK-DAG: Return [<<Const38>>]
+ /// CHECK-START: int Main.inlineNestedCall() inliner (after)
+ /// CHECK-DAG: <<Const38:i\d+>> IntConstant 38
+ /// CHECK-DAG: Return [<<Const38>>]
public static int inlineNestedCall() {
return nestedCall();
diff --git a/test/447-checker-inliner3/src/Main.java b/test/447-checker-inliner3/src/Main.java
index 9d022b9..e3fdffd 100644
--- a/test/447-checker-inliner3/src/Main.java
+++ b/test/447-checker-inliner3/src/Main.java
@@ -16,12 +16,12 @@
public class Main {
- // CHECK-START: int Main.inlineIfThenElse() inliner (before)
- // CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Invoke>>]
+ /// CHECK-START: int Main.inlineIfThenElse() inliner (before)
+ /// CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Invoke>>]
- // CHECK-START: int Main.inlineIfThenElse() inliner (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: int Main.inlineIfThenElse() inliner (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
public static int inlineIfThenElse() {
return foo(true);
@@ -35,11 +35,11 @@
}
}
- // CHECK-START: int Main.inlineInLoop() inliner (before)
- // CHECK-DAG: InvokeStaticOrDirect
+ /// CHECK-START: int Main.inlineInLoop() inliner (before)
+ /// CHECK-DAG: InvokeStaticOrDirect
- // CHECK-START: int Main.inlineInLoop() inliner (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: int Main.inlineInLoop() inliner (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
public static int inlineInLoop() {
int result = 0;
@@ -49,11 +49,11 @@
return result;
}
- // CHECK-START: int Main.inlineInLoopHeader() inliner (before)
- // CHECK-DAG: InvokeStaticOrDirect
+ /// CHECK-START: int Main.inlineInLoopHeader() inliner (before)
+ /// CHECK-DAG: InvokeStaticOrDirect
- // CHECK-START: int Main.inlineInLoopHeader() inliner (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: int Main.inlineInLoopHeader() inliner (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
public static int inlineInLoopHeader() {
int result = 0;
diff --git a/test/449-checker-bce/src/Main.java b/test/449-checker-bce/src/Main.java
index f90d85d..8960df8 100644
--- a/test/449-checker-bce/src/Main.java
+++ b/test/449-checker-bce/src/Main.java
@@ -16,21 +16,21 @@
public class Main {
- // CHECK-START: int Main.sieve(int) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: int Main.sieve(int) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: int Main.sieve(int) BCE (after)
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: int Main.sieve(int) BCE (after)
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
static int sieve(int size) {
int primeCount = 0;
@@ -47,25 +47,25 @@
}
- // CHECK-START: void Main.narrow(int[], int) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.narrow(int[], int) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: void Main.narrow(int[], int) BCE (after)
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.narrow(int[], int) BCE (after)
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
static void narrow(int[] array, int offset) {
if (offset < 0) {
@@ -108,18 +108,18 @@
}
- // CHECK-START: void Main.constantIndexing1(int[]) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.constantIndexing1(int[]) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: void Main.constantIndexing1(int[]) BCE (after)
- // CHECK-NOT: Deoptimize
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.constantIndexing1(int[]) BCE (after)
+ /// CHECK-NOT: Deoptimize
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
static void constantIndexing1(int[] array) {
array[5] = 1;
@@ -127,29 +127,29 @@
}
- // CHECK-START: void Main.constantIndexing2(int[]) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.constantIndexing2(int[]) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: void Main.constantIndexing2(int[]) BCE (after)
- // CHECK: LessThanOrEqual
- // CHECK: Deoptimize
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.constantIndexing2(int[]) BCE (after)
+ /// CHECK: LessThanOrEqual
+ /// CHECK: Deoptimize
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
static void constantIndexing2(int[] array) {
array[1] = 1;
@@ -160,45 +160,45 @@
}
- // CHECK-START: int[] Main.constantIndexing3(int[], int[], boolean) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: int[] Main.constantIndexing3(int[], int[], boolean) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: int[] Main.constantIndexing3(int[], int[], boolean) BCE (after)
- // CHECK: LessThanOrEqual
- // CHECK: Deoptimize
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: LessThanOrEqual
- // CHECK: Deoptimize
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: int[] Main.constantIndexing3(int[], int[], boolean) BCE (after)
+ /// CHECK: LessThanOrEqual
+ /// CHECK: Deoptimize
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: LessThanOrEqual
+ /// CHECK: Deoptimize
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
static int[] constantIndexing3(int[] array1, int[] array2, boolean copy) {
if (!copy) {
@@ -212,14 +212,14 @@
}
- // CHECK-START: void Main.constantIndexing4(int[]) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.constantIndexing4(int[]) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: void Main.constantIndexing4(int[]) BCE (after)
- // CHECK-NOT: LessThanOrEqual
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.constantIndexing4(int[]) BCE (after)
+ /// CHECK-NOT: LessThanOrEqual
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
// There is only one array access. It's not beneficial
// to create a compare with deoptimization instruction.
@@ -228,18 +228,18 @@
}
- // CHECK-START: void Main.constantIndexing5(int[]) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.constantIndexing5(int[]) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: void Main.constantIndexing5(int[]) BCE (after)
- // CHECK-NOT: Deoptimize
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.constantIndexing5(int[]) BCE (after)
+ /// CHECK-NOT: Deoptimize
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
static void constantIndexing5(int[] array) {
// We don't apply the deoptimization for very large constant index
@@ -249,37 +249,37 @@
array[Integer.MAX_VALUE - 998] = 1;
}
- // CHECK-START: void Main.loopPattern1(int[]) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.loopPattern1(int[]) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: void Main.loopPattern1(int[]) BCE (after)
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.loopPattern1(int[]) BCE (after)
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
static void loopPattern1(int[] array) {
for (int i = 0; i < array.length; i++) {
@@ -316,33 +316,33 @@
}
- // CHECK-START: void Main.loopPattern2(int[]) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.loopPattern2(int[]) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: void Main.loopPattern2(int[]) BCE (after)
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.loopPattern2(int[]) BCE (after)
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
static void loopPattern2(int[] array) {
for (int i = array.length - 1; i >= 0; i--) {
@@ -372,13 +372,13 @@
}
- // CHECK-START: void Main.loopPattern3(int[]) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.loopPattern3(int[]) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: void Main.loopPattern3(int[]) BCE (after)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.loopPattern3(int[]) BCE (after)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
static void loopPattern3(int[] array) {
java.util.Random random = new java.util.Random();
@@ -393,29 +393,29 @@
}
- // CHECK-START: void Main.constantNewArray() BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.constantNewArray() BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: void Main.constantNewArray() BCE (after)
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.constantNewArray() BCE (after)
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
static void constantNewArray() {
int[] array = new int[10];
@@ -437,13 +437,13 @@
return 1;
}
- // CHECK-START: void Main.circularBufferProducer() BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.circularBufferProducer() BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: void Main.circularBufferProducer() BCE (after)
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.circularBufferProducer() BCE (after)
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
static void circularBufferProducer() {
byte[] array = new byte[4096];
@@ -455,17 +455,17 @@
}
- // CHECK-START: void Main.pyramid1(int[]) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.pyramid1(int[]) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: void Main.pyramid1(int[]) BCE (after)
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.pyramid1(int[]) BCE (after)
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
// Set array to something like {0, 1, 2, 3, 2, 1, 0}.
static void pyramid1(int[] array) {
@@ -476,17 +476,17 @@
}
- // CHECK-START: void Main.pyramid2(int[]) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.pyramid2(int[]) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: void Main.pyramid2(int[]) BCE (after)
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.pyramid2(int[]) BCE (after)
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
// Set array to something like {0, 1, 2, 3, 2, 1, 0}.
static void pyramid2(int[] array) {
@@ -497,17 +497,17 @@
}
- // CHECK-START: void Main.pyramid3(int[]) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.pyramid3(int[]) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: void Main.pyramid3(int[]) BCE (after)
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.pyramid3(int[]) BCE (after)
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
// Set array to something like {0, 1, 2, 3, 2, 1, 0}.
static void pyramid3(int[] array) {
@@ -518,17 +518,17 @@
}
- // CHECK-START: boolean Main.isPyramid(int[]) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
+ /// CHECK-START: boolean Main.isPyramid(int[]) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
- // CHECK-START: boolean Main.isPyramid(int[]) BCE (after)
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
+ /// CHECK-START: boolean Main.isPyramid(int[]) BCE (after)
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
static boolean isPyramid(int[] array) {
int i = 0;
@@ -546,43 +546,43 @@
}
- // CHECK-START: void Main.bubbleSort(int[]) GVN (before)
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.bubbleSort(int[]) GVN (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: void Main.bubbleSort(int[]) GVN (after)
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK-NOT: ArrayGet
- // CHECK-NOT: ArrayGet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.bubbleSort(int[]) GVN (after)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK-NOT: ArrayGet
+ /// CHECK-NOT: ArrayGet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: void Main.bubbleSort(int[]) BCE (after)
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
- // CHECK-NOT: ArrayGet
- // CHECK-NOT: ArrayGet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.bubbleSort(int[]) BCE (after)
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK-NOT: ArrayGet
+ /// CHECK-NOT: ArrayGet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
static void bubbleSort(int[] array) {
for (int i = 0; i < array.length - 1; i++) {
@@ -610,22 +610,22 @@
int sum;
- // CHECK-START: void Main.foo1(int[], int, int) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
+ /// CHECK-START: void Main.foo1(int[], int, int) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
- // CHECK-START: void Main.foo1(int[], int, int) BCE (after)
- // CHECK: Deoptimize
- // CHECK: Deoptimize
- // CHECK: Deoptimize
- // CHECK-NOT: Deoptimize
- // CHECK: Phi
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
+ /// CHECK-START: void Main.foo1(int[], int, int) BCE (after)
+ /// CHECK: Deoptimize
+ /// CHECK: Deoptimize
+ /// CHECK: Deoptimize
+ /// CHECK-NOT: Deoptimize
+ /// CHECK: Phi
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
void foo1(int[] array, int start, int end) {
// Three HDeoptimize will be added. One for
@@ -639,22 +639,22 @@
}
- // CHECK-START: void Main.foo2(int[], int, int) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
+ /// CHECK-START: void Main.foo2(int[], int, int) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
- // CHECK-START: void Main.foo2(int[], int, int) BCE (after)
- // CHECK: Deoptimize
- // CHECK: Deoptimize
- // CHECK: Deoptimize
- // CHECK-NOT: Deoptimize
- // CHECK: Phi
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
+ /// CHECK-START: void Main.foo2(int[], int, int) BCE (after)
+ /// CHECK: Deoptimize
+ /// CHECK: Deoptimize
+ /// CHECK: Deoptimize
+ /// CHECK-NOT: Deoptimize
+ /// CHECK: Phi
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
void foo2(int[] array, int start, int end) {
// Three HDeoptimize will be added. One for
@@ -668,21 +668,21 @@
}
- // CHECK-START: void Main.foo3(int[], int) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
+ /// CHECK-START: void Main.foo3(int[], int) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
- // CHECK-START: void Main.foo3(int[], int) BCE (after)
- // CHECK: Deoptimize
- // CHECK: Deoptimize
- // CHECK-NOT: Deoptimize
- // CHECK: Phi
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
+ /// CHECK-START: void Main.foo3(int[], int) BCE (after)
+ /// CHECK: Deoptimize
+ /// CHECK: Deoptimize
+ /// CHECK-NOT: Deoptimize
+ /// CHECK: Phi
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
void foo3(int[] array, int end) {
// Two HDeoptimize will be added. One for end < array.length,
@@ -694,21 +694,21 @@
}
}
- // CHECK-START: void Main.foo4(int[], int) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
+ /// CHECK-START: void Main.foo4(int[], int) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
- // CHECK-START: void Main.foo4(int[], int) BCE (after)
- // CHECK: Deoptimize
- // CHECK: Deoptimize
- // CHECK-NOT: Deoptimize
- // CHECK: Phi
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
+ /// CHECK-START: void Main.foo4(int[], int) BCE (after)
+ /// CHECK: Deoptimize
+ /// CHECK: Deoptimize
+ /// CHECK-NOT: Deoptimize
+ /// CHECK: Phi
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
void foo4(int[] array, int end) {
// Two HDeoptimize will be added. One for end <= array.length,
@@ -721,28 +721,28 @@
}
- // CHECK-START: void Main.foo5(int[], int) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
+ /// CHECK-START: void Main.foo5(int[], int) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
- // CHECK-START: void Main.foo5(int[], int) BCE (after)
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
- // CHECK: Deoptimize
- // CHECK-NOT: Deoptimize
- // CHECK: Phi
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
+ /// CHECK-START: void Main.foo5(int[], int) BCE (after)
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
+ /// CHECK: Deoptimize
+ /// CHECK-NOT: Deoptimize
+ /// CHECK: Phi
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
void foo5(int[] array, int end) {
// Bounds check in this loop can be eliminated without deoptimization.
@@ -759,38 +759,38 @@
}
- // CHECK-START: void Main.foo6(int[], int, int) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.foo6(int[], int, int) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: void Main.foo6(int[], int, int) BCE (after)
- // CHECK: Deoptimize
- // CHECK: Deoptimize
- // CHECK: Deoptimize
- // CHECK-NOT: Deoptimize
- // CHECK: Phi
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.foo6(int[], int, int) BCE (after)
+ /// CHECK: Deoptimize
+ /// CHECK: Deoptimize
+ /// CHECK: Deoptimize
+ /// CHECK-NOT: Deoptimize
+ /// CHECK: Phi
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArraySet
void foo6(int[] array, int start, int end) {
// Three HDeoptimize will be added. One for
@@ -803,22 +803,22 @@
}
- // CHECK-START: void Main.foo7(int[], int, int, boolean) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
+ /// CHECK-START: void Main.foo7(int[], int, int, boolean) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
- // CHECK-START: void Main.foo7(int[], int, int, boolean) BCE (after)
- // CHECK: Deoptimize
- // CHECK: Deoptimize
- // CHECK: Deoptimize
- // CHECK-NOT: Deoptimize
- // CHECK: Phi
- // CHECK: BoundsCheck
- // CHECK: ArrayGet
- // CHECK-NOT: BoundsCheck
- // CHECK: ArrayGet
+ /// CHECK-START: void Main.foo7(int[], int, int, boolean) BCE (after)
+ /// CHECK: Deoptimize
+ /// CHECK: Deoptimize
+ /// CHECK: Deoptimize
+ /// CHECK-NOT: Deoptimize
+ /// CHECK: Phi
+ /// CHECK: BoundsCheck
+ /// CHECK: ArrayGet
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK: ArrayGet
void foo7(int[] array, int start, int end, boolean lowEnd) {
// Three HDeoptimize will be added. One for
@@ -837,14 +837,14 @@
}
- // CHECK-START: void Main.partialLooping(int[], int, int) BCE (before)
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.partialLooping(int[], int, int) BCE (before)
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
- // CHECK-START: void Main.partialLooping(int[], int, int) BCE (after)
- // CHECK-NOT: Deoptimize
- // CHECK: BoundsCheck
- // CHECK: ArraySet
+ /// CHECK-START: void Main.partialLooping(int[], int, int) BCE (after)
+ /// CHECK-NOT: Deoptimize
+ /// CHECK: BoundsCheck
+ /// CHECK: ArraySet
void partialLooping(int[] array, int start, int end) {
// This loop doesn't cover the full range of [start, end) so
@@ -983,8 +983,8 @@
}
// Make sure this method is compiled with optimizing.
- // CHECK-START: void Main.main(java.lang.String[]) register (after)
- // CHECK: ParallelMove
+ /// CHECK-START: void Main.main(java.lang.String[]) register (after)
+ /// CHECK: ParallelMove
public static void main(String[] args) {
sieve(20);
diff --git a/test/450-checker-types/src/Main.java b/test/450-checker-types/src/Main.java
index 640aeb8..e907622 100644
--- a/test/450-checker-types/src/Main.java
+++ b/test/450-checker-types/src/Main.java
@@ -54,50 +54,50 @@
public class Main {
- // CHECK-START: void Main.testSimpleRemove() instruction_simplifier_after_types (before)
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testSimpleRemove() instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
- // CHECK-START: void Main.testSimpleRemove() instruction_simplifier_after_types (after)
- // CHECK-NOT: CheckCast
+ /// CHECK-START: void Main.testSimpleRemove() instruction_simplifier_after_types (after)
+ /// CHECK-NOT: CheckCast
public void testSimpleRemove() {
Super s = new SubclassA();
((SubclassA)s).g();
}
- // CHECK-START: void Main.testSimpleKeep(Super) instruction_simplifier_after_types (before)
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testSimpleKeep(Super) instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
- // CHECK-START: void Main.testSimpleKeep(Super) instruction_simplifier_after_types (after)
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testSimpleKeep(Super) instruction_simplifier_after_types (after)
+ /// CHECK: CheckCast
public void testSimpleKeep(Super s) {
((SubclassA)s).f();
}
- // CHECK-START: java.lang.String Main.testClassRemove() instruction_simplifier_after_types (before)
- // CHECK: CheckCast
+ /// CHECK-START: java.lang.String Main.testClassRemove() instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
- // CHECK-START: java.lang.String Main.testClassRemove() instruction_simplifier_after_types (after)
- // CHECK-NOT: CheckCast
+ /// CHECK-START: java.lang.String Main.testClassRemove() instruction_simplifier_after_types (after)
+ /// CHECK-NOT: CheckCast
public String testClassRemove() {
Object s = SubclassA.class;
return ((Class)s).getName();
}
- // CHECK-START: java.lang.String Main.testClassKeep() instruction_simplifier_after_types (before)
- // CHECK: CheckCast
+ /// CHECK-START: java.lang.String Main.testClassKeep() instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
- // CHECK-START: java.lang.String Main.testClassKeep() instruction_simplifier_after_types (after)
- // CHECK: CheckCast
+ /// CHECK-START: java.lang.String Main.testClassKeep() instruction_simplifier_after_types (after)
+ /// CHECK: CheckCast
public String testClassKeep() {
Object s = SubclassA.class;
return ((SubclassA)s).h();
}
- // CHECK-START: void Main.testIfRemove(int) instruction_simplifier_after_types (before)
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testIfRemove(int) instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
- // CHECK-START: void Main.testIfRemove(int) instruction_simplifier_after_types (after)
- // CHECK-NOT: CheckCast
+ /// CHECK-START: void Main.testIfRemove(int) instruction_simplifier_after_types (after)
+ /// CHECK-NOT: CheckCast
public void testIfRemove(int x) {
Super s;
if (x % 2 == 0) {
@@ -108,11 +108,11 @@
((SubclassA)s).g();
}
- // CHECK-START: void Main.testIfKeep(int) instruction_simplifier_after_types (before)
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testIfKeep(int) instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
- // CHECK-START: void Main.testIfKeep(int) instruction_simplifier_after_types (after)
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testIfKeep(int) instruction_simplifier_after_types (after)
+ /// CHECK: CheckCast
public void testIfKeep(int x) {
Super s;
if (x % 2 == 0) {
@@ -123,11 +123,11 @@
((SubclassA)s).g();
}
- // CHECK-START: void Main.testForRemove(int) instruction_simplifier_after_types (before)
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testForRemove(int) instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
- // CHECK-START: void Main.testForRemove(int) instruction_simplifier_after_types (after)
- // CHECK-NOT: CheckCast
+ /// CHECK-START: void Main.testForRemove(int) instruction_simplifier_after_types (after)
+ /// CHECK-NOT: CheckCast
public void testForRemove(int x) {
Super s = new SubclassA();
for (int i = 0 ; i < x; i++) {
@@ -138,11 +138,11 @@
((SubclassA)s).g();
}
- // CHECK-START: void Main.testForKeep(int) instruction_simplifier_after_types (before)
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testForKeep(int) instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
- // CHECK-START: void Main.testForKeep(int) instruction_simplifier_after_types (after)
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testForKeep(int) instruction_simplifier_after_types (after)
+ /// CHECK: CheckCast
public void testForKeep(int x) {
Super s = new SubclassA();
for (int i = 0 ; i < x; i++) {
@@ -153,11 +153,11 @@
((SubclassC)s).g();
}
- // CHECK-START: void Main.testPhiFromCall(int) instruction_simplifier_after_types (before)
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testPhiFromCall(int) instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
- // CHECK-START: void Main.testPhiFromCall(int) instruction_simplifier_after_types (after)
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testPhiFromCall(int) instruction_simplifier_after_types (after)
+ /// CHECK: CheckCast
public void testPhiFromCall(int i) {
Object x;
if (i % 2 == 0) {
@@ -168,12 +168,12 @@
((SubclassC)x).g();
}
- // CHECK-START: void Main.testInstanceOf(java.lang.Object) instruction_simplifier_after_types (before)
- // CHECK: CheckCast
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testInstanceOf(java.lang.Object) instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
+ /// CHECK: CheckCast
- // CHECK-START: void Main.testInstanceOf(java.lang.Object) instruction_simplifier_after_types (after)
- // CHECK-NOT: CheckCast
+ /// CHECK-START: void Main.testInstanceOf(java.lang.Object) instruction_simplifier_after_types (after)
+ /// CHECK-NOT: CheckCast
public void testInstanceOf(Object o) {
if (o instanceof SubclassC) {
((SubclassC)o).g();
@@ -183,13 +183,13 @@
}
}
- // CHECK-START: void Main.testInstanceOfKeep(java.lang.Object) instruction_simplifier_after_types (before)
- // CHECK: CheckCast
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testInstanceOfKeep(java.lang.Object) instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
+ /// CHECK: CheckCast
- // CHECK-START: void Main.testInstanceOfKeep(java.lang.Object) instruction_simplifier_after_types (after)
- // CHECK: CheckCast
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testInstanceOfKeep(java.lang.Object) instruction_simplifier_after_types (after)
+ /// CHECK: CheckCast
+ /// CHECK: CheckCast
public void testInstanceOfKeep(Object o) {
if (o instanceof SubclassC) {
((SubclassB)o).g();
@@ -199,12 +199,12 @@
}
}
- // CHECK-START: void Main.testInstanceOfNested(java.lang.Object) instruction_simplifier_after_types (before)
- // CHECK: CheckCast
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testInstanceOfNested(java.lang.Object) instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
+ /// CHECK: CheckCast
- // CHECK-START: void Main.testInstanceOfNested(java.lang.Object) instruction_simplifier_after_types (after)
- // CHECK-NOT: CheckCast
+ /// CHECK-START: void Main.testInstanceOfNested(java.lang.Object) instruction_simplifier_after_types (after)
+ /// CHECK-NOT: CheckCast
public void testInstanceOfNested(Object o) {
if (o instanceof SubclassC) {
if (o instanceof SubclassB) {
@@ -215,11 +215,11 @@
}
}
- // CHECK-START: void Main.testInstanceOfWithPhi(int) instruction_simplifier_after_types (before)
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testInstanceOfWithPhi(int) instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
- // CHECK-START: void Main.testInstanceOfWithPhi(int) instruction_simplifier_after_types (after)
- // CHECK-NOT: CheckCast
+ /// CHECK-START: void Main.testInstanceOfWithPhi(int) instruction_simplifier_after_types (after)
+ /// CHECK-NOT: CheckCast
public void testInstanceOfWithPhi(int i) {
Object o;
if (i == 0) {
@@ -233,11 +233,11 @@
}
}
- // CHECK-START: void Main.testInstanceOfInFor(int) instruction_simplifier_after_types (before)
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testInstanceOfInFor(int) instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
- // CHECK-START: void Main.testInstanceOfInFor(int) instruction_simplifier_after_types (after)
- // CHECK-NOT: CheckCast
+ /// CHECK-START: void Main.testInstanceOfInFor(int) instruction_simplifier_after_types (after)
+ /// CHECK-NOT: CheckCast
public void testInstanceOfInFor(int n) {
Object o = new SubclassA();
for (int i = 0; i < n; i++) {
@@ -250,11 +250,11 @@
}
}
- // CHECK-START: void Main.testInstanceOfSubclass() instruction_simplifier_after_types (before)
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testInstanceOfSubclass() instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
- // CHECK-START: void Main.testInstanceOfSubclass() instruction_simplifier_after_types (after)
- // CHECK-NOT: CheckCast
+ /// CHECK-START: void Main.testInstanceOfSubclass() instruction_simplifier_after_types (after)
+ /// CHECK-NOT: CheckCast
public void testInstanceOfSubclass() {
Object o = new SubclassA();
if (o instanceof Super) {
@@ -262,11 +262,11 @@
}
}
- // CHECK-START: void Main.testInstanceOfWithPhiSubclass(int) instruction_simplifier_after_types (before)
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testInstanceOfWithPhiSubclass(int) instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
- // CHECK-START: void Main.testInstanceOfWithPhiSubclass(int) instruction_simplifier_after_types (after)
- // CHECK-NOT: CheckCast
+ /// CHECK-START: void Main.testInstanceOfWithPhiSubclass(int) instruction_simplifier_after_types (after)
+ /// CHECK-NOT: CheckCast
public void testInstanceOfWithPhiSubclass(int i) {
Object o;
if (i == 0) {
@@ -280,11 +280,11 @@
}
}
- // CHECK-START: void Main.testInstanceOfWithPhiTop(int) instruction_simplifier_after_types (before)
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testInstanceOfWithPhiTop(int) instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
- // CHECK-START: void Main.testInstanceOfWithPhiTop(int) instruction_simplifier_after_types (after)
- // CHECK-NOT: CheckCast
+ /// CHECK-START: void Main.testInstanceOfWithPhiTop(int) instruction_simplifier_after_types (after)
+ /// CHECK-NOT: CheckCast
public void testInstanceOfWithPhiTop(int i) {
Object o;
if (i == 0) {
@@ -298,11 +298,11 @@
}
}
- // CHECK-START: void Main.testInstanceOfSubclassInFor(int) instruction_simplifier_after_types (before)
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testInstanceOfSubclassInFor(int) instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
- // CHECK-START: void Main.testInstanceOfSubclassInFor(int) instruction_simplifier_after_types (after)
- // CHECK-NOT: CheckCast
+ /// CHECK-START: void Main.testInstanceOfSubclassInFor(int) instruction_simplifier_after_types (after)
+ /// CHECK-NOT: CheckCast
public void testInstanceOfSubclassInFor(int n) {
Object o = new SubclassA();
for (int i = 0; i < n; i++) {
@@ -315,11 +315,11 @@
}
}
- // CHECK-START: void Main.testInstanceOfTopInFor(int) instruction_simplifier_after_types (before)
- // CHECK: CheckCast
+ /// CHECK-START: void Main.testInstanceOfTopInFor(int) instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
- // CHECK-START: void Main.testInstanceOfTopInFor(int) instruction_simplifier_after_types (after)
- // CHECK-NOT: CheckCast
+ /// CHECK-START: void Main.testInstanceOfTopInFor(int) instruction_simplifier_after_types (after)
+ /// CHECK-NOT: CheckCast
public void testInstanceOfTopInFor(int n) {
Object o = new SubclassA();
for (int i = 0; i < n; i++) {
diff --git a/test/455-checker-gvn/src/Main.java b/test/455-checker-gvn/src/Main.java
index e94fc46..9824f27 100644
--- a/test/455-checker-gvn/src/Main.java
+++ b/test/455-checker-gvn/src/Main.java
@@ -19,15 +19,15 @@
System.out.println(foo(3, 4));
}
- // CHECK-START: int Main.foo(int, int) GVN (before)
- // CHECK: Add
- // CHECK: Add
- // CHECK: Add
+ /// CHECK-START: int Main.foo(int, int) GVN (before)
+ /// CHECK: Add
+ /// CHECK: Add
+ /// CHECK: Add
- // CHECK-START: int Main.foo(int, int) GVN (after)
- // CHECK: Add
- // CHECK: Add
- // CHECK-NOT: Add
+ /// CHECK-START: int Main.foo(int, int) GVN (after)
+ /// CHECK: Add
+ /// CHECK: Add
+ /// CHECK-NOT: Add
public static int foo(int x, int y) {
int sum1 = x + y;
diff --git a/test/458-checker-instruction-simplification/src/Main.java b/test/458-checker-instruction-simplification/src/Main.java
index 742210c..ad5fc8e 100644
--- a/test/458-checker-instruction-simplification/src/Main.java
+++ b/test/458-checker-instruction-simplification/src/Main.java
@@ -50,296 +50,296 @@
* Tiny programs exercising optimizations of arithmetic identities.
*/
- // CHECK-START: long Main.Add0(long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Const0:j\d+>> LongConstant 0
- // CHECK-DAG: <<Add:j\d+>> Add [<<Const0>>,<<Arg>>]
- // CHECK-DAG: Return [<<Add>>]
+ /// CHECK-START: long Main.Add0(long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:j\d+>> LongConstant 0
+ /// CHECK-DAG: <<Add:j\d+>> Add [<<Const0>>,<<Arg>>]
+ /// CHECK-DAG: Return [<<Add>>]
- // CHECK-START: long Main.Add0(long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: long Main.Add0(long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: long Main.Add0(long) instruction_simplifier (after)
- // CHECK-NOT: Add
+ /// CHECK-START: long Main.Add0(long) instruction_simplifier (after)
+ /// CHECK-NOT: Add
public static long Add0(long arg) {
return 0 + arg;
}
- // CHECK-START: int Main.AndAllOnes(int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<ConstF:i\d+>> IntConstant -1
- // CHECK-DAG: <<And:i\d+>> And [<<Arg>>,<<ConstF>>]
- // CHECK-DAG: Return [<<And>>]
+ /// CHECK-START: int Main.AndAllOnes(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstF:i\d+>> IntConstant -1
+ /// CHECK-DAG: <<And:i\d+>> And [<<Arg>>,<<ConstF>>]
+ /// CHECK-DAG: Return [<<And>>]
- // CHECK-START: int Main.AndAllOnes(int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: int Main.AndAllOnes(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: int Main.AndAllOnes(int) instruction_simplifier (after)
- // CHECK-NOT: And
+ /// CHECK-START: int Main.AndAllOnes(int) instruction_simplifier (after)
+ /// CHECK-NOT: And
public static int AndAllOnes(int arg) {
return arg & -1;
}
- // CHECK-START: long Main.Div1(long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Const1:j\d+>> LongConstant 1
- // CHECK-DAG: <<Div:j\d+>> Div [<<Arg>>,<<Const1>>]
- // CHECK-DAG: Return [<<Div>>]
+ /// CHECK-START: long Main.Div1(long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const1:j\d+>> LongConstant 1
+ /// CHECK-DAG: <<Div:j\d+>> Div [<<Arg>>,<<Const1>>]
+ /// CHECK-DAG: Return [<<Div>>]
- // CHECK-START: long Main.Div1(long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: long Main.Div1(long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: long Main.Div1(long) instruction_simplifier (after)
- // CHECK-NOT: Div
+ /// CHECK-START: long Main.Div1(long) instruction_simplifier (after)
+ /// CHECK-NOT: Div
public static long Div1(long arg) {
return arg / 1;
}
- // CHECK-START: int Main.DivN1(int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<ConstN1:i\d+>> IntConstant -1
- // CHECK-DAG: <<Div:i\d+>> Div [<<Arg>>,<<ConstN1>>]
- // CHECK-DAG: Return [<<Div>>]
+ /// CHECK-START: int Main.DivN1(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstN1:i\d+>> IntConstant -1
+ /// CHECK-DAG: <<Div:i\d+>> Div [<<Arg>>,<<ConstN1>>]
+ /// CHECK-DAG: Return [<<Div>>]
- // CHECK-START: int Main.DivN1(int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg>>]
- // CHECK-DAG: Return [<<Neg>>]
+ /// CHECK-START: int Main.DivN1(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg>>]
+ /// CHECK-DAG: Return [<<Neg>>]
- // CHECK-START: int Main.DivN1(int) instruction_simplifier (after)
- // CHECK-NOT: Div
+ /// CHECK-START: int Main.DivN1(int) instruction_simplifier (after)
+ /// CHECK-NOT: Div
public static int DivN1(int arg) {
return arg / -1;
}
- // CHECK-START: long Main.Mul1(long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Const1:j\d+>> LongConstant 1
- // CHECK-DAG: <<Mul:j\d+>> Mul [<<Arg>>,<<Const1>>]
- // CHECK-DAG: Return [<<Mul>>]
+ /// CHECK-START: long Main.Mul1(long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const1:j\d+>> LongConstant 1
+ /// CHECK-DAG: <<Mul:j\d+>> Mul [<<Arg>>,<<Const1>>]
+ /// CHECK-DAG: Return [<<Mul>>]
- // CHECK-START: long Main.Mul1(long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: long Main.Mul1(long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: long Main.Mul1(long) instruction_simplifier (after)
- // CHECK-NOT: Mul
+ /// CHECK-START: long Main.Mul1(long) instruction_simplifier (after)
+ /// CHECK-NOT: Mul
public static long Mul1(long arg) {
return arg * 1;
}
- // CHECK-START: int Main.MulN1(int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<ConstN1:i\d+>> IntConstant -1
- // CHECK-DAG: <<Mul:i\d+>> Mul [<<Arg>>,<<ConstN1>>]
- // CHECK-DAG: Return [<<Mul>>]
+ /// CHECK-START: int Main.MulN1(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstN1:i\d+>> IntConstant -1
+ /// CHECK-DAG: <<Mul:i\d+>> Mul [<<Arg>>,<<ConstN1>>]
+ /// CHECK-DAG: Return [<<Mul>>]
- // CHECK-START: int Main.MulN1(int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg>>]
- // CHECK-DAG: Return [<<Neg>>]
+ /// CHECK-START: int Main.MulN1(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg>>]
+ /// CHECK-DAG: Return [<<Neg>>]
- // CHECK-START: int Main.MulN1(int) instruction_simplifier (after)
- // CHECK-NOT: Mul
+ /// CHECK-START: int Main.MulN1(int) instruction_simplifier (after)
+ /// CHECK-NOT: Mul
public static int MulN1(int arg) {
return arg * -1;
}
- // CHECK-START: long Main.MulPowerOfTwo128(long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Const128:j\d+>> LongConstant 128
- // CHECK-DAG: <<Mul:j\d+>> Mul [<<Arg>>,<<Const128>>]
- // CHECK-DAG: Return [<<Mul>>]
+ /// CHECK-START: long Main.MulPowerOfTwo128(long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const128:j\d+>> LongConstant 128
+ /// CHECK-DAG: <<Mul:j\d+>> Mul [<<Arg>>,<<Const128>>]
+ /// CHECK-DAG: Return [<<Mul>>]
- // CHECK-START: long Main.MulPowerOfTwo128(long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Const7:i\d+>> IntConstant 7
- // CHECK-DAG: <<Shl:j\d+>> Shl [<<Arg>>,<<Const7>>]
- // CHECK-DAG: Return [<<Shl>>]
+ /// CHECK-START: long Main.MulPowerOfTwo128(long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const7:i\d+>> IntConstant 7
+ /// CHECK-DAG: <<Shl:j\d+>> Shl [<<Arg>>,<<Const7>>]
+ /// CHECK-DAG: Return [<<Shl>>]
- // CHECK-START: long Main.MulPowerOfTwo128(long) instruction_simplifier (after)
- // CHECK-NOT: Mul
+ /// CHECK-START: long Main.MulPowerOfTwo128(long) instruction_simplifier (after)
+ /// CHECK-NOT: Mul
public static long MulPowerOfTwo128(long arg) {
return arg * 128;
}
- // CHECK-START: int Main.Or0(int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Or:i\d+>> Or [<<Arg>>,<<Const0>>]
- // CHECK-DAG: Return [<<Or>>]
+ /// CHECK-START: int Main.Or0(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Or:i\d+>> Or [<<Arg>>,<<Const0>>]
+ /// CHECK-DAG: Return [<<Or>>]
- // CHECK-START: int Main.Or0(int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: int Main.Or0(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: int Main.Or0(int) instruction_simplifier (after)
- // CHECK-NOT: Or
+ /// CHECK-START: int Main.Or0(int) instruction_simplifier (after)
+ /// CHECK-NOT: Or
public static int Or0(int arg) {
return arg | 0;
}
- // CHECK-START: long Main.OrSame(long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Or:j\d+>> Or [<<Arg>>,<<Arg>>]
- // CHECK-DAG: Return [<<Or>>]
+ /// CHECK-START: long Main.OrSame(long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Or:j\d+>> Or [<<Arg>>,<<Arg>>]
+ /// CHECK-DAG: Return [<<Or>>]
- // CHECK-START: long Main.OrSame(long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: long Main.OrSame(long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: long Main.OrSame(long) instruction_simplifier (after)
- // CHECK-NOT: Or
+ /// CHECK-START: long Main.OrSame(long) instruction_simplifier (after)
+ /// CHECK-NOT: Or
public static long OrSame(long arg) {
return arg | arg;
}
- // CHECK-START: int Main.Shl0(int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Shl:i\d+>> Shl [<<Arg>>,<<Const0>>]
- // CHECK-DAG: Return [<<Shl>>]
+ /// CHECK-START: int Main.Shl0(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Shl:i\d+>> Shl [<<Arg>>,<<Const0>>]
+ /// CHECK-DAG: Return [<<Shl>>]
- // CHECK-START: int Main.Shl0(int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: int Main.Shl0(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: int Main.Shl0(int) instruction_simplifier (after)
- // CHECK-NOT: Shl
+ /// CHECK-START: int Main.Shl0(int) instruction_simplifier (after)
+ /// CHECK-NOT: Shl
public static int Shl0(int arg) {
return arg << 0;
}
- // CHECK-START: int Main.Shl1(int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: <<Shl:i\d+>> Shl [<<Arg>>,<<Const1>>]
- // CHECK-DAG: Return [<<Shl>>]
+ /// CHECK-START: int Main.Shl1(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<Shl:i\d+>> Shl [<<Arg>>,<<Const1>>]
+ /// CHECK-DAG: Return [<<Shl>>]
- // CHECK-START: int Main.Shl1(int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Add:i\d+>> Add [<<Arg>>,<<Arg>>]
- // CHECK-DAG: Return [<<Add>>]
+ /// CHECK-START: int Main.Shl1(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<Arg>>,<<Arg>>]
+ /// CHECK-DAG: Return [<<Add>>]
- // CHECK-START: int Main.Shl1(int) instruction_simplifier (after)
- // CHECK-NOT: Shl
+ /// CHECK-START: int Main.Shl1(int) instruction_simplifier (after)
+ /// CHECK-NOT: Shl
public static int Shl1(int arg) {
return arg << 1;
}
- // CHECK-START: long Main.Shr0(long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Shr:j\d+>> Shr [<<Arg>>,<<Const0>>]
- // CHECK-DAG: Return [<<Shr>>]
+ /// CHECK-START: long Main.Shr0(long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Shr:j\d+>> Shr [<<Arg>>,<<Const0>>]
+ /// CHECK-DAG: Return [<<Shr>>]
- // CHECK-START: long Main.Shr0(long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: long Main.Shr0(long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: long Main.Shr0(long) instruction_simplifier (after)
- // CHECK-NOT: Shr
+ /// CHECK-START: long Main.Shr0(long) instruction_simplifier (after)
+ /// CHECK-NOT: Shr
public static long Shr0(long arg) {
return arg >> 0;
}
- // CHECK-START: long Main.Sub0(long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Const0:j\d+>> LongConstant 0
- // CHECK-DAG: <<Sub:j\d+>> Sub [<<Arg>>,<<Const0>>]
- // CHECK-DAG: Return [<<Sub>>]
+ /// CHECK-START: long Main.Sub0(long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:j\d+>> LongConstant 0
+ /// CHECK-DAG: <<Sub:j\d+>> Sub [<<Arg>>,<<Const0>>]
+ /// CHECK-DAG: Return [<<Sub>>]
- // CHECK-START: long Main.Sub0(long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: long Main.Sub0(long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: long Main.Sub0(long) instruction_simplifier (after)
- // CHECK-NOT: Sub
+ /// CHECK-START: long Main.Sub0(long) instruction_simplifier (after)
+ /// CHECK-NOT: Sub
public static long Sub0(long arg) {
return arg - 0;
}
- // CHECK-START: int Main.SubAliasNeg(int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Sub:i\d+>> Sub [<<Const0>>,<<Arg>>]
- // CHECK-DAG: Return [<<Sub>>]
+ /// CHECK-START: int Main.SubAliasNeg(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Const0>>,<<Arg>>]
+ /// CHECK-DAG: Return [<<Sub>>]
- // CHECK-START: int Main.SubAliasNeg(int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg>>]
- // CHECK-DAG: Return [<<Neg>>]
+ /// CHECK-START: int Main.SubAliasNeg(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg>>]
+ /// CHECK-DAG: Return [<<Neg>>]
- // CHECK-START: int Main.SubAliasNeg(int) instruction_simplifier (after)
- // CHECK-NOT: Sub
+ /// CHECK-START: int Main.SubAliasNeg(int) instruction_simplifier (after)
+ /// CHECK-NOT: Sub
public static int SubAliasNeg(int arg) {
return 0 - arg;
}
- // CHECK-START: long Main.UShr0(long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<UShr:j\d+>> UShr [<<Arg>>,<<Const0>>]
- // CHECK-DAG: Return [<<UShr>>]
+ /// CHECK-START: long Main.UShr0(long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<UShr:j\d+>> UShr [<<Arg>>,<<Const0>>]
+ /// CHECK-DAG: Return [<<UShr>>]
- // CHECK-START: long Main.UShr0(long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: long Main.UShr0(long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: long Main.UShr0(long) instruction_simplifier (after)
- // CHECK-NOT: UShr
+ /// CHECK-START: long Main.UShr0(long) instruction_simplifier (after)
+ /// CHECK-NOT: UShr
public static long UShr0(long arg) {
return arg >>> 0;
}
- // CHECK-START: int Main.Xor0(int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Xor:i\d+>> Xor [<<Arg>>,<<Const0>>]
- // CHECK-DAG: Return [<<Xor>>]
+ /// CHECK-START: int Main.Xor0(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Xor:i\d+>> Xor [<<Arg>>,<<Const0>>]
+ /// CHECK-DAG: Return [<<Xor>>]
- // CHECK-START: int Main.Xor0(int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: int Main.Xor0(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: int Main.Xor0(int) instruction_simplifier (after)
- // CHECK-NOT: Xor
+ /// CHECK-START: int Main.Xor0(int) instruction_simplifier (after)
+ /// CHECK-NOT: Xor
public static int Xor0(int arg) {
return arg ^ 0;
}
- // CHECK-START: int Main.XorAllOnes(int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<ConstF:i\d+>> IntConstant -1
- // CHECK-DAG: <<Xor:i\d+>> Xor [<<Arg>>,<<ConstF>>]
- // CHECK-DAG: Return [<<Xor>>]
+ /// CHECK-START: int Main.XorAllOnes(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstF:i\d+>> IntConstant -1
+ /// CHECK-DAG: <<Xor:i\d+>> Xor [<<Arg>>,<<ConstF>>]
+ /// CHECK-DAG: Return [<<Xor>>]
- // CHECK-START: int Main.XorAllOnes(int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Not:i\d+>> Not [<<Arg>>]
- // CHECK-DAG: Return [<<Not>>]
+ /// CHECK-START: int Main.XorAllOnes(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Not:i\d+>> Not [<<Arg>>]
+ /// CHECK-DAG: Return [<<Not>>]
- // CHECK-START: int Main.XorAllOnes(int) instruction_simplifier (after)
- // CHECK-NOT: Xor
+ /// CHECK-START: int Main.XorAllOnes(int) instruction_simplifier (after)
+ /// CHECK-NOT: Xor
public static int XorAllOnes(int arg) {
return arg ^ -1;
@@ -352,21 +352,21 @@
* `InstructionSimplifierVisitor::TryMoveNegOnInputsAfterBinop`.
*/
- // CHECK-START: int Main.AddNegs1(int, int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg1>>]
- // CHECK-DAG: <<Neg2:i\d+>> Neg [<<Arg2>>]
- // CHECK-DAG: <<Add:i\d+>> Add [<<Neg1>>,<<Neg2>>]
- // CHECK-DAG: Return [<<Add>>]
+ /// CHECK-START: int Main.AddNegs1(int, int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg1>>]
+ /// CHECK-DAG: <<Neg2:i\d+>> Neg [<<Arg2>>]
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<Neg1>>,<<Neg2>>]
+ /// CHECK-DAG: Return [<<Add>>]
- // CHECK-START: int Main.AddNegs1(int, int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-NOT: Neg
- // CHECK-DAG: <<Add:i\d+>> Add [<<Arg1>>,<<Arg2>>]
- // CHECK-DAG: <<Neg:i\d+>> Neg [<<Add>>]
- // CHECK-DAG: Return [<<Neg>>]
+ /// CHECK-START: int Main.AddNegs1(int, int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-NOT: Neg
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<Arg1>>,<<Arg2>>]
+ /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Add>>]
+ /// CHECK-DAG: Return [<<Neg>>]
public static int AddNegs1(int arg1, int arg2) {
return -arg1 + -arg2;
@@ -383,35 +383,35 @@
* increasing the register pressure by creating or extending live ranges.
*/
- // CHECK-START: int Main.AddNegs2(int, int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg1>>]
- // CHECK-DAG: <<Neg2:i\d+>> Neg [<<Arg2>>]
- // CHECK-DAG: <<Add1:i\d+>> Add [<<Neg1>>,<<Neg2>>]
- // CHECK-DAG: <<Add2:i\d+>> Add [<<Neg1>>,<<Neg2>>]
- // CHECK-DAG: <<Or:i\d+>> Or [<<Add1>>,<<Add2>>]
- // CHECK-DAG: Return [<<Or>>]
+ /// CHECK-START: int Main.AddNegs2(int, int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg1>>]
+ /// CHECK-DAG: <<Neg2:i\d+>> Neg [<<Arg2>>]
+ /// CHECK-DAG: <<Add1:i\d+>> Add [<<Neg1>>,<<Neg2>>]
+ /// CHECK-DAG: <<Add2:i\d+>> Add [<<Neg1>>,<<Neg2>>]
+ /// CHECK-DAG: <<Or:i\d+>> Or [<<Add1>>,<<Add2>>]
+ /// CHECK-DAG: Return [<<Or>>]
- // CHECK-START: int Main.AddNegs2(int, int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg1>>]
- // CHECK-DAG: <<Neg2:i\d+>> Neg [<<Arg2>>]
- // CHECK-DAG: <<Add1:i\d+>> Add [<<Neg1>>,<<Neg2>>]
- // CHECK-DAG: <<Add2:i\d+>> Add [<<Neg1>>,<<Neg2>>]
- // CHECK-NOT: Neg
- // CHECK-DAG: <<Or:i\d+>> Or [<<Add1>>,<<Add2>>]
- // CHECK-DAG: Return [<<Or>>]
+ /// CHECK-START: int Main.AddNegs2(int, int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg1>>]
+ /// CHECK-DAG: <<Neg2:i\d+>> Neg [<<Arg2>>]
+ /// CHECK-DAG: <<Add1:i\d+>> Add [<<Neg1>>,<<Neg2>>]
+ /// CHECK-DAG: <<Add2:i\d+>> Add [<<Neg1>>,<<Neg2>>]
+ /// CHECK-NOT: Neg
+ /// CHECK-DAG: <<Or:i\d+>> Or [<<Add1>>,<<Add2>>]
+ /// CHECK-DAG: Return [<<Or>>]
- // CHECK-START: int Main.AddNegs2(int, int) GVN (after)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg1>>]
- // CHECK-DAG: <<Neg2:i\d+>> Neg [<<Arg2>>]
- // CHECK-DAG: <<Add:i\d+>> Add [<<Neg1>>,<<Neg2>>]
- // CHECK-DAG: <<Or:i\d+>> Or [<<Add>>,<<Add>>]
- // CHECK-DAG: Return [<<Or>>]
+ /// CHECK-START: int Main.AddNegs2(int, int) GVN (after)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg1>>]
+ /// CHECK-DAG: <<Neg2:i\d+>> Neg [<<Arg2>>]
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<Neg1>>,<<Neg2>>]
+ /// CHECK-DAG: <<Or:i\d+>> Or [<<Add>>,<<Add>>]
+ /// CHECK-DAG: Return [<<Or>>]
public static int AddNegs2(int arg1, int arg2) {
int temp1 = -arg1;
@@ -427,30 +427,30 @@
* the loop.
*/
- // CHECK-START: long Main.AddNegs3(long, long) instruction_simplifier (before)
- // -------------- Arguments and initial negation operations.
- // CHECK-DAG: <<Arg1:j\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:j\d+>> ParameterValue
- // CHECK-DAG: <<Neg1:j\d+>> Neg [<<Arg1>>]
- // CHECK-DAG: <<Neg2:j\d+>> Neg [<<Arg2>>]
- // CHECK: Goto
- // -------------- Loop
- // CHECK: SuspendCheck
- // CHECK: <<Add:j\d+>> Add [<<Neg1>>,<<Neg2>>]
- // CHECK: Goto
+ /// CHECK-START: long Main.AddNegs3(long, long) instruction_simplifier (before)
+ // -------------- Arguments and initial negation operations.
+ /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg1:j\d+>> Neg [<<Arg1>>]
+ /// CHECK-DAG: <<Neg2:j\d+>> Neg [<<Arg2>>]
+ /// CHECK: Goto
+ // -------------- Loop
+ /// CHECK: SuspendCheck
+ /// CHECK: <<Add:j\d+>> Add [<<Neg1>>,<<Neg2>>]
+ /// CHECK: Goto
- // CHECK-START: long Main.AddNegs3(long, long) instruction_simplifier (after)
- // -------------- Arguments and initial negation operations.
- // CHECK-DAG: <<Arg1:j\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:j\d+>> ParameterValue
- // CHECK-DAG: <<Neg1:j\d+>> Neg [<<Arg1>>]
- // CHECK-DAG: <<Neg2:j\d+>> Neg [<<Arg2>>]
- // CHECK: Goto
- // -------------- Loop
- // CHECK: SuspendCheck
- // CHECK: <<Add:j\d+>> Add [<<Neg1>>,<<Neg2>>]
- // CHECK-NOT: Neg
- // CHECK: Goto
+ /// CHECK-START: long Main.AddNegs3(long, long) instruction_simplifier (after)
+ // -------------- Arguments and initial negation operations.
+ /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg1:j\d+>> Neg [<<Arg1>>]
+ /// CHECK-DAG: <<Neg2:j\d+>> Neg [<<Arg2>>]
+ /// CHECK: Goto
+ // -------------- Loop
+ /// CHECK: SuspendCheck
+ /// CHECK: <<Add:j\d+>> Add [<<Neg1>>,<<Neg2>>]
+ /// CHECK-NOT: Neg
+ /// CHECK: Goto
public static long AddNegs3(long arg1, long arg2) {
long res = 0;
@@ -468,22 +468,22 @@
* The transformation tested is implemented in `InstructionSimplifierVisitor::VisitAdd`.
*/
- // CHECK-START: long Main.AddNeg1(long, long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg1:j\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:j\d+>> ParameterValue
- // CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg1>>]
- // CHECK-DAG: <<Add:j\d+>> Add [<<Neg>>,<<Arg2>>]
- // CHECK-DAG: Return [<<Add>>]
+ /// CHECK-START: long Main.AddNeg1(long, long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg1>>]
+ /// CHECK-DAG: <<Add:j\d+>> Add [<<Neg>>,<<Arg2>>]
+ /// CHECK-DAG: Return [<<Add>>]
- // CHECK-START: long Main.AddNeg1(long, long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg1:j\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:j\d+>> ParameterValue
- // CHECK-DAG: <<Sub:j\d+>> Sub [<<Arg2>>,<<Arg1>>]
- // CHECK-DAG: Return [<<Sub>>]
+ /// CHECK-START: long Main.AddNeg1(long, long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Sub:j\d+>> Sub [<<Arg2>>,<<Arg1>>]
+ /// CHECK-DAG: Return [<<Sub>>]
- // CHECK-START: long Main.AddNeg1(long, long) instruction_simplifier (after)
- // CHECK-NOT: Neg
- // CHECK-NOT: Add
+ /// CHECK-START: long Main.AddNeg1(long, long) instruction_simplifier (after)
+ /// CHECK-NOT: Neg
+ /// CHECK-NOT: Add
public static long AddNeg1(long arg1, long arg2) {
return -arg1 + arg2;
@@ -498,26 +498,26 @@
* increasing the register pressure by creating or extending live ranges.
*/
- // CHECK-START: long Main.AddNeg2(long, long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg1:j\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:j\d+>> ParameterValue
- // CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg2>>]
- // CHECK-DAG: <<Add1:j\d+>> Add [<<Arg1>>,<<Neg>>]
- // CHECK-DAG: <<Add2:j\d+>> Add [<<Arg1>>,<<Neg>>]
- // CHECK-DAG: <<Res:j\d+>> Or [<<Add1>>,<<Add2>>]
- // CHECK-DAG: Return [<<Res>>]
+ /// CHECK-START: long Main.AddNeg2(long, long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg2>>]
+ /// CHECK-DAG: <<Add1:j\d+>> Add [<<Arg1>>,<<Neg>>]
+ /// CHECK-DAG: <<Add2:j\d+>> Add [<<Arg1>>,<<Neg>>]
+ /// CHECK-DAG: <<Res:j\d+>> Or [<<Add1>>,<<Add2>>]
+ /// CHECK-DAG: Return [<<Res>>]
- // CHECK-START: long Main.AddNeg2(long, long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg1:j\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:j\d+>> ParameterValue
- // CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg2>>]
- // CHECK-DAG: <<Add1:j\d+>> Add [<<Arg1>>,<<Neg>>]
- // CHECK-DAG: <<Add2:j\d+>> Add [<<Arg1>>,<<Neg>>]
- // CHECK-DAG: <<Res:j\d+>> Or [<<Add1>>,<<Add2>>]
- // CHECK-DAG: Return [<<Res>>]
+ /// CHECK-START: long Main.AddNeg2(long, long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg2>>]
+ /// CHECK-DAG: <<Add1:j\d+>> Add [<<Arg1>>,<<Neg>>]
+ /// CHECK-DAG: <<Add2:j\d+>> Add [<<Arg1>>,<<Neg>>]
+ /// CHECK-DAG: <<Res:j\d+>> Or [<<Add1>>,<<Add2>>]
+ /// CHECK-DAG: Return [<<Res>>]
- // CHECK-START: long Main.AddNeg2(long, long) instruction_simplifier (after)
- // CHECK-NOT: Sub
+ /// CHECK-START: long Main.AddNeg2(long, long) instruction_simplifier (after)
+ /// CHECK-NOT: Sub
public static long AddNeg2(long arg1, long arg2) {
long temp = -arg2;
@@ -529,18 +529,18 @@
* The transformation tested is implemented in `InstructionSimplifierVisitor::VisitNeg`.
*/
- // CHECK-START: long Main.NegNeg1(long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Neg1:j\d+>> Neg [<<Arg>>]
- // CHECK-DAG: <<Neg2:j\d+>> Neg [<<Neg1>>]
- // CHECK-DAG: Return [<<Neg2>>]
+ /// CHECK-START: long Main.NegNeg1(long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg1:j\d+>> Neg [<<Arg>>]
+ /// CHECK-DAG: <<Neg2:j\d+>> Neg [<<Neg1>>]
+ /// CHECK-DAG: Return [<<Neg2>>]
- // CHECK-START: long Main.NegNeg1(long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: long Main.NegNeg1(long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: long Main.NegNeg1(long) instruction_simplifier (after)
- // CHECK-NOT: Neg
+ /// CHECK-START: long Main.NegNeg1(long) instruction_simplifier (after)
+ /// CHECK-NOT: Neg
public static long NegNeg1(long arg) {
return -(-arg);
@@ -553,27 +553,27 @@
* and in `InstructionSimplifierVisitor::VisitAdd`.
*/
- // CHECK-START: int Main.NegNeg2(int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg>>]
- // CHECK-DAG: <<Neg2:i\d+>> Neg [<<Neg1>>]
- // CHECK-DAG: <<Add:i\d+>> Add [<<Neg1>>,<<Neg2>>]
- // CHECK-DAG: Return [<<Add>>]
+ /// CHECK-START: int Main.NegNeg2(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg>>]
+ /// CHECK-DAG: <<Neg2:i\d+>> Neg [<<Neg1>>]
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<Neg1>>,<<Neg2>>]
+ /// CHECK-DAG: Return [<<Add>>]
- // CHECK-START: int Main.NegNeg2(int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg>>,<<Arg>>]
- // CHECK-DAG: Return [<<Sub>>]
+ /// CHECK-START: int Main.NegNeg2(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg>>,<<Arg>>]
+ /// CHECK-DAG: Return [<<Sub>>]
- // CHECK-START: int Main.NegNeg2(int) instruction_simplifier (after)
- // CHECK-NOT: Neg
- // CHECK-NOT: Add
+ /// CHECK-START: int Main.NegNeg2(int) instruction_simplifier (after)
+ /// CHECK-NOT: Neg
+ /// CHECK-NOT: Add
- // CHECK-START: int Main.NegNeg2(int) constant_folding_after_inlining (after)
- // CHECK: <<Const0:i\d+>> IntConstant 0
- // CHECK-NOT: Neg
- // CHECK-NOT: Add
- // CHECK: Return [<<Const0>>]
+ /// CHECK-START: int Main.NegNeg2(int) constant_folding_after_inlining (after)
+ /// CHECK: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-NOT: Neg
+ /// CHECK-NOT: Add
+ /// CHECK: Return [<<Const0>>]
public static int NegNeg2(int arg) {
int temp = -arg;
@@ -587,20 +587,20 @@
* and in `InstructionSimplifierVisitor::VisitSub`.
*/
- // CHECK-START: long Main.NegNeg3(long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<Const0:j\d+>> LongConstant 0
- // CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg>>]
- // CHECK-DAG: <<Sub:j\d+>> Sub [<<Const0>>,<<Neg>>]
- // CHECK-DAG: Return [<<Sub>>]
+ /// CHECK-START: long Main.NegNeg3(long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:j\d+>> LongConstant 0
+ /// CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg>>]
+ /// CHECK-DAG: <<Sub:j\d+>> Sub [<<Const0>>,<<Neg>>]
+ /// CHECK-DAG: Return [<<Sub>>]
- // CHECK-START: long Main.NegNeg3(long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: long Main.NegNeg3(long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: long Main.NegNeg3(long) instruction_simplifier (after)
- // CHECK-NOT: Neg
- // CHECK-NOT: Sub
+ /// CHECK-START: long Main.NegNeg3(long) instruction_simplifier (after)
+ /// CHECK-NOT: Neg
+ /// CHECK-NOT: Sub
public static long NegNeg3(long arg) {
return 0 - -arg;
@@ -612,21 +612,21 @@
* The transformation tested is implemented in `InstructionSimplifierVisitor::VisitNeg`.
*/
- // CHECK-START: int Main.NegSub1(int, int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg1>>,<<Arg2>>]
- // CHECK-DAG: <<Neg:i\d+>> Neg [<<Sub>>]
- // CHECK-DAG: Return [<<Neg>>]
+ /// CHECK-START: int Main.NegSub1(int, int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg1>>,<<Arg2>>]
+ /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Sub>>]
+ /// CHECK-DAG: Return [<<Neg>>]
- // CHECK-START: int Main.NegSub1(int, int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg2>>,<<Arg1>>]
- // CHECK-DAG: Return [<<Sub>>]
+ /// CHECK-START: int Main.NegSub1(int, int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg2>>,<<Arg1>>]
+ /// CHECK-DAG: Return [<<Sub>>]
- // CHECK-START: int Main.NegSub1(int, int) instruction_simplifier (after)
- // CHECK-NOT: Neg
+ /// CHECK-START: int Main.NegSub1(int, int) instruction_simplifier (after)
+ /// CHECK-NOT: Neg
public static int NegSub1(int arg1, int arg2) {
return -(arg1 - arg2);
@@ -642,23 +642,23 @@
* increasing the register pressure by creating or extending live ranges.
*/
- // CHECK-START: int Main.NegSub2(int, int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg1>>,<<Arg2>>]
- // CHECK-DAG: <<Neg1:i\d+>> Neg [<<Sub>>]
- // CHECK-DAG: <<Neg2:i\d+>> Neg [<<Sub>>]
- // CHECK-DAG: <<Or:i\d+>> Or [<<Neg1>>,<<Neg2>>]
- // CHECK-DAG: Return [<<Or>>]
+ /// CHECK-START: int Main.NegSub2(int, int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg1>>,<<Arg2>>]
+ /// CHECK-DAG: <<Neg1:i\d+>> Neg [<<Sub>>]
+ /// CHECK-DAG: <<Neg2:i\d+>> Neg [<<Sub>>]
+ /// CHECK-DAG: <<Or:i\d+>> Or [<<Neg1>>,<<Neg2>>]
+ /// CHECK-DAG: Return [<<Or>>]
- // CHECK-START: int Main.NegSub2(int, int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg1>>,<<Arg2>>]
- // CHECK-DAG: <<Neg1:i\d+>> Neg [<<Sub>>]
- // CHECK-DAG: <<Neg2:i\d+>> Neg [<<Sub>>]
- // CHECK-DAG: <<Or:i\d+>> Or [<<Neg1>>,<<Neg2>>]
- // CHECK-DAG: Return [<<Or>>]
+ /// CHECK-START: int Main.NegSub2(int, int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg1>>,<<Arg2>>]
+ /// CHECK-DAG: <<Neg1:i\d+>> Neg [<<Sub>>]
+ /// CHECK-DAG: <<Neg2:i\d+>> Neg [<<Sub>>]
+ /// CHECK-DAG: <<Or:i\d+>> Or [<<Neg1>>,<<Neg2>>]
+ /// CHECK-DAG: Return [<<Or>>]
public static int NegSub2(int arg1, int arg2) {
int temp = arg1 - arg2;
@@ -670,40 +670,40 @@
* The transformation tested is implemented in `InstructionSimplifierVisitor::VisitNot`.
*/
- // CHECK-START: long Main.NotNot1(long) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: <<ConstF1:j\d+>> LongConstant -1
- // CHECK-DAG: <<Xor1:j\d+>> Xor [<<Arg>>,<<ConstF1>>]
- // CHECK-DAG: <<Xor2:j\d+>> Xor [<<Xor1>>,<<ConstF1>>]
- // CHECK-DAG: Return [<<Xor2>>]
+ /// CHECK-START: long Main.NotNot1(long) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstF1:j\d+>> LongConstant -1
+ /// CHECK-DAG: <<Xor1:j\d+>> Xor [<<Arg>>,<<ConstF1>>]
+ /// CHECK-DAG: <<Xor2:j\d+>> Xor [<<Xor1>>,<<ConstF1>>]
+ /// CHECK-DAG: Return [<<Xor2>>]
- // CHECK-START: long Main.NotNot1(long) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:j\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: long Main.NotNot1(long) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:j\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: long Main.NotNot1(long) instruction_simplifier (after)
- // CHECK-NOT: Xor
+ /// CHECK-START: long Main.NotNot1(long) instruction_simplifier (after)
+ /// CHECK-NOT: Xor
public static long NotNot1(long arg) {
return ~~arg;
}
- // CHECK-START: int Main.NotNot2(int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<ConstF1:i\d+>> IntConstant -1
- // CHECK-DAG: <<Xor1:i\d+>> Xor [<<Arg>>,<<ConstF1>>]
- // CHECK-DAG: <<Xor2:i\d+>> Xor [<<Xor1>>,<<ConstF1>>]
- // CHECK-DAG: <<Add:i\d+>> Add [<<Xor1>>,<<Xor2>>]
- // CHECK-DAG: Return [<<Add>>]
+ /// CHECK-START: int Main.NotNot2(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstF1:i\d+>> IntConstant -1
+ /// CHECK-DAG: <<Xor1:i\d+>> Xor [<<Arg>>,<<ConstF1>>]
+ /// CHECK-DAG: <<Xor2:i\d+>> Xor [<<Xor1>>,<<ConstF1>>]
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<Xor1>>,<<Xor2>>]
+ /// CHECK-DAG: Return [<<Add>>]
- // CHECK-START: int Main.NotNot2(int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: <<Not:i\d+>> Not [<<Arg>>]
- // CHECK-DAG: <<Add:i\d+>> Add [<<Not>>,<<Arg>>]
- // CHECK-DAG: Return [<<Add>>]
+ /// CHECK-START: int Main.NotNot2(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Not:i\d+>> Not [<<Arg>>]
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<Not>>,<<Arg>>]
+ /// CHECK-DAG: Return [<<Add>>]
- // CHECK-START: int Main.NotNot2(int) instruction_simplifier (after)
- // CHECK-NOT: Xor
+ /// CHECK-START: int Main.NotNot2(int) instruction_simplifier (after)
+ /// CHECK-NOT: Xor
public static int NotNot2(int arg) {
int temp = ~arg;
@@ -715,22 +715,22 @@
* The transformation tested is implemented in `InstructionSimplifierVisitor::VisitSub`.
*/
- // CHECK-START: int Main.SubNeg1(int, int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg1>>]
- // CHECK-DAG: <<Sub:i\d+>> Sub [<<Neg>>,<<Arg2>>]
- // CHECK-DAG: Return [<<Sub>>]
+ /// CHECK-START: int Main.SubNeg1(int, int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg1>>]
+ /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Neg>>,<<Arg2>>]
+ /// CHECK-DAG: Return [<<Sub>>]
- // CHECK-START: int Main.SubNeg1(int, int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-DAG: <<Add:i\d+>> Add [<<Arg1>>,<<Arg2>>]
- // CHECK-DAG: <<Neg:i\d+>> Neg [<<Add>>]
- // CHECK-DAG: Return [<<Neg>>]
+ /// CHECK-START: int Main.SubNeg1(int, int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<Arg1>>,<<Arg2>>]
+ /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Add>>]
+ /// CHECK-DAG: Return [<<Neg>>]
- // CHECK-START: int Main.SubNeg1(int, int) instruction_simplifier (after)
- // CHECK-NOT: Sub
+ /// CHECK-START: int Main.SubNeg1(int, int) instruction_simplifier (after)
+ /// CHECK-NOT: Sub
public static int SubNeg1(int arg1, int arg2) {
return -arg1 - arg2;
@@ -746,26 +746,26 @@
* increasing the register pressure by creating or extending live ranges.
*/
- // CHECK-START: int Main.SubNeg2(int, int) instruction_simplifier (before)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg1>>]
- // CHECK-DAG: <<Sub1:i\d+>> Sub [<<Neg>>,<<Arg2>>]
- // CHECK-DAG: <<Sub2:i\d+>> Sub [<<Neg>>,<<Arg2>>]
- // CHECK-DAG: <<Or:i\d+>> Or [<<Sub1>>,<<Sub2>>]
- // CHECK-DAG: Return [<<Or>>]
+ /// CHECK-START: int Main.SubNeg2(int, int) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg1>>]
+ /// CHECK-DAG: <<Sub1:i\d+>> Sub [<<Neg>>,<<Arg2>>]
+ /// CHECK-DAG: <<Sub2:i\d+>> Sub [<<Neg>>,<<Arg2>>]
+ /// CHECK-DAG: <<Or:i\d+>> Or [<<Sub1>>,<<Sub2>>]
+ /// CHECK-DAG: Return [<<Or>>]
- // CHECK-START: int Main.SubNeg2(int, int) instruction_simplifier (after)
- // CHECK-DAG: <<Arg1:i\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:i\d+>> ParameterValue
- // CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg1>>]
- // CHECK-DAG: <<Sub1:i\d+>> Sub [<<Neg>>,<<Arg2>>]
- // CHECK-DAG: <<Sub2:i\d+>> Sub [<<Neg>>,<<Arg2>>]
- // CHECK-DAG: <<Or:i\d+>> Or [<<Sub1>>,<<Sub2>>]
- // CHECK-DAG: Return [<<Or>>]
+ /// CHECK-START: int Main.SubNeg2(int, int) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg1>>]
+ /// CHECK-DAG: <<Sub1:i\d+>> Sub [<<Neg>>,<<Arg2>>]
+ /// CHECK-DAG: <<Sub2:i\d+>> Sub [<<Neg>>,<<Arg2>>]
+ /// CHECK-DAG: <<Or:i\d+>> Or [<<Sub1>>,<<Sub2>>]
+ /// CHECK-DAG: Return [<<Or>>]
- // CHECK-START: int Main.SubNeg2(int, int) instruction_simplifier (after)
- // CHECK-NOT: Add
+ /// CHECK-START: int Main.SubNeg2(int, int) instruction_simplifier (after)
+ /// CHECK-NOT: Add
public static int SubNeg2(int arg1, int arg2) {
int temp = -arg1;
@@ -779,28 +779,28 @@
* the loop.
*/
- // CHECK-START: long Main.SubNeg3(long, long) instruction_simplifier (before)
- // -------------- Arguments and initial negation operation.
- // CHECK-DAG: <<Arg1:j\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:j\d+>> ParameterValue
- // CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg1>>]
- // CHECK: Goto
- // -------------- Loop
- // CHECK: SuspendCheck
- // CHECK: <<Sub:j\d+>> Sub [<<Neg>>,<<Arg2>>]
- // CHECK: Goto
+ /// CHECK-START: long Main.SubNeg3(long, long) instruction_simplifier (before)
+ // -------------- Arguments and initial negation operation.
+ /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg1>>]
+ /// CHECK: Goto
+ // -------------- Loop
+ /// CHECK: SuspendCheck
+ /// CHECK: <<Sub:j\d+>> Sub [<<Neg>>,<<Arg2>>]
+ /// CHECK: Goto
- // CHECK-START: long Main.SubNeg3(long, long) instruction_simplifier (after)
- // -------------- Arguments and initial negation operation.
- // CHECK-DAG: <<Arg1:j\d+>> ParameterValue
- // CHECK-DAG: <<Arg2:j\d+>> ParameterValue
- // CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg1>>]
- // CHECK-DAG: Goto
- // -------------- Loop
- // CHECK: SuspendCheck
- // CHECK: <<Sub:j\d+>> Sub [<<Neg>>,<<Arg2>>]
- // CHECK-NOT: Neg
- // CHECK: Goto
+ /// CHECK-START: long Main.SubNeg3(long, long) instruction_simplifier (after)
+ // -------------- Arguments and initial negation operation.
+ /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg1>>]
+ /// CHECK-DAG: Goto
+ // -------------- Loop
+ /// CHECK: SuspendCheck
+ /// CHECK: <<Sub:j\d+>> Sub [<<Neg>>,<<Arg2>>]
+ /// CHECK-NOT: Neg
+ /// CHECK: Goto
public static long SubNeg3(long arg1, long arg2) {
long res = 0;
@@ -811,117 +811,117 @@
return res;
}
- // CHECK-START: int Main.EqualTrueRhs(boolean) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: <<Cond:z\d+>> Equal [<<Arg>>,<<Const1>>]
- // CHECK-DAG: If [<<Cond>>]
+ /// CHECK-START: int Main.EqualTrueRhs(boolean) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<Cond:z\d+>> Equal [<<Arg>>,<<Const1>>]
+ /// CHECK-DAG: If [<<Cond>>]
- // CHECK-START: int Main.EqualTrueRhs(boolean) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: If [<<Arg>>]
+ /// CHECK-START: int Main.EqualTrueRhs(boolean) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: If [<<Arg>>]
public static int EqualTrueRhs(boolean arg) {
return (arg != true) ? 3 : 5;
}
- // CHECK-START: int Main.EqualTrueLhs(boolean) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: <<Cond:z\d+>> Equal [<<Const1>>,<<Arg>>]
- // CHECK-DAG: If [<<Cond>>]
+ /// CHECK-START: int Main.EqualTrueLhs(boolean) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<Cond:z\d+>> Equal [<<Const1>>,<<Arg>>]
+ /// CHECK-DAG: If [<<Cond>>]
- // CHECK-START: int Main.EqualTrueLhs(boolean) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: If [<<Arg>>]
+ /// CHECK-START: int Main.EqualTrueLhs(boolean) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: If [<<Arg>>]
public static int EqualTrueLhs(boolean arg) {
return (true != arg) ? 3 : 5;
}
- // CHECK-START: int Main.EqualFalseRhs(boolean) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Cond:z\d+>> Equal [<<Arg>>,<<Const0>>]
- // CHECK-DAG: If [<<Cond>>]
+ /// CHECK-START: int Main.EqualFalseRhs(boolean) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Cond:z\d+>> Equal [<<Arg>>,<<Const0>>]
+ /// CHECK-DAG: If [<<Cond>>]
- // CHECK-START: int Main.EqualFalseRhs(boolean) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<NotArg:z\d+>> BooleanNot [<<Arg>>]
- // CHECK-DAG: If [<<NotArg>>]
+ /// CHECK-START: int Main.EqualFalseRhs(boolean) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<NotArg:z\d+>> BooleanNot [<<Arg>>]
+ /// CHECK-DAG: If [<<NotArg>>]
public static int EqualFalseRhs(boolean arg) {
return (arg != false) ? 3 : 5;
}
- // CHECK-START: int Main.EqualFalseLhs(boolean) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Cond:z\d+>> Equal [<<Const0>>,<<Arg>>]
- // CHECK-DAG: If [<<Cond>>]
+ /// CHECK-START: int Main.EqualFalseLhs(boolean) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Cond:z\d+>> Equal [<<Const0>>,<<Arg>>]
+ /// CHECK-DAG: If [<<Cond>>]
- // CHECK-START: int Main.EqualFalseLhs(boolean) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<NotArg:z\d+>> BooleanNot [<<Arg>>]
- // CHECK-DAG: If [<<NotArg>>]
+ /// CHECK-START: int Main.EqualFalseLhs(boolean) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<NotArg:z\d+>> BooleanNot [<<Arg>>]
+ /// CHECK-DAG: If [<<NotArg>>]
public static int EqualFalseLhs(boolean arg) {
return (false != arg) ? 3 : 5;
}
- // CHECK-START: int Main.NotEqualTrueRhs(boolean) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: <<Cond:z\d+>> NotEqual [<<Arg>>,<<Const1>>]
- // CHECK-DAG: If [<<Cond>>]
+ /// CHECK-START: int Main.NotEqualTrueRhs(boolean) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<Cond:z\d+>> NotEqual [<<Arg>>,<<Const1>>]
+ /// CHECK-DAG: If [<<Cond>>]
- // CHECK-START: int Main.NotEqualTrueRhs(boolean) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<NotArg:z\d+>> BooleanNot [<<Arg>>]
- // CHECK-DAG: If [<<NotArg>>]
+ /// CHECK-START: int Main.NotEqualTrueRhs(boolean) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<NotArg:z\d+>> BooleanNot [<<Arg>>]
+ /// CHECK-DAG: If [<<NotArg>>]
public static int NotEqualTrueRhs(boolean arg) {
return (arg == true) ? 3 : 5;
}
- // CHECK-START: int Main.NotEqualTrueLhs(boolean) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: <<Cond:z\d+>> NotEqual [<<Const1>>,<<Arg>>]
- // CHECK-DAG: If [<<Cond>>]
+ /// CHECK-START: int Main.NotEqualTrueLhs(boolean) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<Cond:z\d+>> NotEqual [<<Const1>>,<<Arg>>]
+ /// CHECK-DAG: If [<<Cond>>]
- // CHECK-START: int Main.NotEqualTrueLhs(boolean) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<NotArg:z\d+>> BooleanNot [<<Arg>>]
- // CHECK-DAG: If [<<NotArg>>]
+ /// CHECK-START: int Main.NotEqualTrueLhs(boolean) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<NotArg:z\d+>> BooleanNot [<<Arg>>]
+ /// CHECK-DAG: If [<<NotArg>>]
public static int NotEqualTrueLhs(boolean arg) {
return (true == arg) ? 3 : 5;
}
- // CHECK-START: int Main.NotEqualFalseRhs(boolean) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Cond:z\d+>> NotEqual [<<Arg>>,<<Const0>>]
- // CHECK-DAG: If [<<Cond>>]
+ /// CHECK-START: int Main.NotEqualFalseRhs(boolean) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Cond:z\d+>> NotEqual [<<Arg>>,<<Const0>>]
+ /// CHECK-DAG: If [<<Cond>>]
- // CHECK-START: int Main.NotEqualFalseRhs(boolean) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: If [<<Arg>>]
+ /// CHECK-START: int Main.NotEqualFalseRhs(boolean) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: If [<<Arg>>]
public static int NotEqualFalseRhs(boolean arg) {
return (arg == false) ? 3 : 5;
}
- // CHECK-START: int Main.NotEqualFalseLhs(boolean) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Cond:z\d+>> NotEqual [<<Const0>>,<<Arg>>]
- // CHECK-DAG: If [<<Cond>>]
+ /// CHECK-START: int Main.NotEqualFalseLhs(boolean) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Cond:z\d+>> NotEqual [<<Const0>>,<<Arg>>]
+ /// CHECK-DAG: If [<<Cond>>]
- // CHECK-START: int Main.NotEqualFalseLhs(boolean) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: If [<<Arg>>]
+ /// CHECK-START: int Main.NotEqualFalseLhs(boolean) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: If [<<Arg>>]
public static int NotEqualFalseLhs(boolean arg) {
return (false == arg) ? 3 : 5;
@@ -933,20 +933,20 @@
* remove the second.
*/
- // CHECK-START: boolean Main.NotNotBool(boolean) instruction_simplifier_after_types (before)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: <<NotArg:z\d+>> BooleanNot [<<Arg>>]
- // CHECK-DAG: <<NotNotArg:z\d+>> BooleanNot [<<NotArg>>]
- // CHECK-DAG: Return [<<NotNotArg>>]
+ /// CHECK-START: boolean Main.NotNotBool(boolean) instruction_simplifier_after_types (before)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: <<NotArg:z\d+>> BooleanNot [<<Arg>>]
+ /// CHECK-DAG: <<NotNotArg:z\d+>> BooleanNot [<<NotArg>>]
+ /// CHECK-DAG: Return [<<NotNotArg>>]
- // CHECK-START: boolean Main.NotNotBool(boolean) instruction_simplifier_after_types (after)
- // CHECK-DAG: <<Arg:z\d+>> ParameterValue
- // CHECK-DAG: BooleanNot [<<Arg>>]
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: boolean Main.NotNotBool(boolean) instruction_simplifier_after_types (after)
+ /// CHECK-DAG: <<Arg:z\d+>> ParameterValue
+ /// CHECK-DAG: BooleanNot [<<Arg>>]
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: boolean Main.NotNotBool(boolean) instruction_simplifier_after_types (after)
- // CHECK: BooleanNot
- // CHECK-NOT: BooleanNot
+ /// CHECK-START: boolean Main.NotNotBool(boolean) instruction_simplifier_after_types (after)
+ /// CHECK: BooleanNot
+ /// CHECK-NOT: BooleanNot
public static boolean NegateValue(boolean arg) {
return !arg;
@@ -956,76 +956,76 @@
return !(NegateValue(arg));
}
- // CHECK-START: float Main.Div2(float) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:f\d+>> ParameterValue
- // CHECK-DAG: <<Const2:f\d+>> FloatConstant 2
- // CHECK-DAG: <<Div:f\d+>> Div [<<Arg>>,<<Const2>>]
- // CHECK-DAG: Return [<<Div>>]
+ /// CHECK-START: float Main.Div2(float) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:f\d+>> ParameterValue
+ /// CHECK-DAG: <<Const2:f\d+>> FloatConstant 2
+ /// CHECK-DAG: <<Div:f\d+>> Div [<<Arg>>,<<Const2>>]
+ /// CHECK-DAG: Return [<<Div>>]
- // CHECK-START: float Main.Div2(float) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:f\d+>> ParameterValue
- // CHECK-DAG: <<ConstP5:f\d+>> FloatConstant 0.5
- // CHECK-DAG: <<Mul:f\d+>> Mul [<<Arg>>,<<ConstP5>>]
- // CHECK-DAG: Return [<<Mul>>]
+ /// CHECK-START: float Main.Div2(float) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:f\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstP5:f\d+>> FloatConstant 0.5
+ /// CHECK-DAG: <<Mul:f\d+>> Mul [<<Arg>>,<<ConstP5>>]
+ /// CHECK-DAG: Return [<<Mul>>]
- // CHECK-START: float Main.Div2(float) instruction_simplifier (after)
- // CHECK-NOT: Div
+ /// CHECK-START: float Main.Div2(float) instruction_simplifier (after)
+ /// CHECK-NOT: Div
public static float Div2(float arg) {
return arg / 2.0f;
}
- // CHECK-START: double Main.Div2(double) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:d\d+>> ParameterValue
- // CHECK-DAG: <<Const2:d\d+>> DoubleConstant 2
- // CHECK-DAG: <<Div:d\d+>> Div [<<Arg>>,<<Const2>>]
- // CHECK-DAG: Return [<<Div>>]
+ /// CHECK-START: double Main.Div2(double) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:d\d+>> ParameterValue
+ /// CHECK-DAG: <<Const2:d\d+>> DoubleConstant 2
+ /// CHECK-DAG: <<Div:d\d+>> Div [<<Arg>>,<<Const2>>]
+ /// CHECK-DAG: Return [<<Div>>]
- // CHECK-START: double Main.Div2(double) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:d\d+>> ParameterValue
- // CHECK-DAG: <<ConstP5:d\d+>> DoubleConstant 0.5
- // CHECK-DAG: <<Mul:d\d+>> Mul [<<Arg>>,<<ConstP5>>]
- // CHECK-DAG: Return [<<Mul>>]
+ /// CHECK-START: double Main.Div2(double) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:d\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstP5:d\d+>> DoubleConstant 0.5
+ /// CHECK-DAG: <<Mul:d\d+>> Mul [<<Arg>>,<<ConstP5>>]
+ /// CHECK-DAG: Return [<<Mul>>]
- // CHECK-START: double Main.Div2(double) instruction_simplifier (after)
- // CHECK-NOT: Div
+ /// CHECK-START: double Main.Div2(double) instruction_simplifier (after)
+ /// CHECK-NOT: Div
public static double Div2(double arg) {
return arg / 2.0;
}
- // CHECK-START: float Main.DivMP25(float) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:f\d+>> ParameterValue
- // CHECK-DAG: <<ConstMP25:f\d+>> FloatConstant -0.25
- // CHECK-DAG: <<Div:f\d+>> Div [<<Arg>>,<<ConstMP25>>]
- // CHECK-DAG: Return [<<Div>>]
+ /// CHECK-START: float Main.DivMP25(float) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:f\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstMP25:f\d+>> FloatConstant -0.25
+ /// CHECK-DAG: <<Div:f\d+>> Div [<<Arg>>,<<ConstMP25>>]
+ /// CHECK-DAG: Return [<<Div>>]
- // CHECK-START: float Main.DivMP25(float) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:f\d+>> ParameterValue
- // CHECK-DAG: <<ConstM4:f\d+>> FloatConstant -4
- // CHECK-DAG: <<Mul:f\d+>> Mul [<<Arg>>,<<ConstM4>>]
- // CHECK-DAG: Return [<<Mul>>]
+ /// CHECK-START: float Main.DivMP25(float) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:f\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstM4:f\d+>> FloatConstant -4
+ /// CHECK-DAG: <<Mul:f\d+>> Mul [<<Arg>>,<<ConstM4>>]
+ /// CHECK-DAG: Return [<<Mul>>]
- // CHECK-START: float Main.DivMP25(float) instruction_simplifier (after)
- // CHECK-NOT: Div
+ /// CHECK-START: float Main.DivMP25(float) instruction_simplifier (after)
+ /// CHECK-NOT: Div
public static float DivMP25(float arg) {
return arg / -0.25f;
}
- // CHECK-START: double Main.DivMP25(double) instruction_simplifier (before)
- // CHECK-DAG: <<Arg:d\d+>> ParameterValue
- // CHECK-DAG: <<ConstMP25:d\d+>> DoubleConstant -0.25
- // CHECK-DAG: <<Div:d\d+>> Div [<<Arg>>,<<ConstMP25>>]
- // CHECK-DAG: Return [<<Div>>]
+ /// CHECK-START: double Main.DivMP25(double) instruction_simplifier (before)
+ /// CHECK-DAG: <<Arg:d\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstMP25:d\d+>> DoubleConstant -0.25
+ /// CHECK-DAG: <<Div:d\d+>> Div [<<Arg>>,<<ConstMP25>>]
+ /// CHECK-DAG: Return [<<Div>>]
- // CHECK-START: double Main.DivMP25(double) instruction_simplifier (after)
- // CHECK-DAG: <<Arg:d\d+>> ParameterValue
- // CHECK-DAG: <<ConstM4:d\d+>> DoubleConstant -4
- // CHECK-DAG: <<Mul:d\d+>> Mul [<<Arg>>,<<ConstM4>>]
- // CHECK-DAG: Return [<<Mul>>]
+ /// CHECK-START: double Main.DivMP25(double) instruction_simplifier (after)
+ /// CHECK-DAG: <<Arg:d\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstM4:d\d+>> DoubleConstant -4
+ /// CHECK-DAG: <<Mul:d\d+>> Mul [<<Arg>>,<<ConstM4>>]
+ /// CHECK-DAG: Return [<<Mul>>]
- // CHECK-START: double Main.DivMP25(double) instruction_simplifier (after)
- // CHECK-NOT: Div
+ /// CHECK-START: double Main.DivMP25(double) instruction_simplifier (after)
+ /// CHECK-NOT: Div
public static double DivMP25(double arg) {
return arg / -0.25f;
}
diff --git a/test/462-checker-inlining-across-dex-files/src/Main.java b/test/462-checker-inlining-across-dex-files/src/Main.java
index 218c7ce..64979ca 100644
--- a/test/462-checker-inlining-across-dex-files/src/Main.java
+++ b/test/462-checker-inlining-across-dex-files/src/Main.java
@@ -21,105 +21,105 @@
public class Main {
- // CHECK-START: void Main.inlineEmptyMethod() inliner (before)
- // CHECK-DAG: <<Invoke:v\d+>> InvokeStaticOrDirect
- // CHECK-DAG: ReturnVoid
+ /// CHECK-START: void Main.inlineEmptyMethod() inliner (before)
+ /// CHECK-DAG: <<Invoke:v\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: ReturnVoid
- // CHECK-START: void Main.inlineEmptyMethod() inliner (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: void Main.inlineEmptyMethod() inliner (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
public static void inlineEmptyMethod() {
OtherDex.emptyMethod();
}
- // CHECK-START: int Main.inlineReturnIntMethod() inliner (before)
- // CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Invoke>>]
+ /// CHECK-START: int Main.inlineReturnIntMethod() inliner (before)
+ /// CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Invoke>>]
- // CHECK-START: int Main.inlineReturnIntMethod() inliner (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: int Main.inlineReturnIntMethod() inliner (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
- // CHECK-START: int Main.inlineReturnIntMethod() inliner (after)
- // CHECK-DAG: <<Const38:i\d+>> IntConstant 38
- // CHECK-DAG: Return [<<Const38>>]
+ /// CHECK-START: int Main.inlineReturnIntMethod() inliner (after)
+ /// CHECK-DAG: <<Const38:i\d+>> IntConstant 38
+ /// CHECK-DAG: Return [<<Const38>>]
public static int inlineReturnIntMethod() {
return OtherDex.returnIntMethod();
}
- // CHECK-START: int Main.dontInlineOtherDexStatic() inliner (before)
- // CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Invoke>>]
+ /// CHECK-START: int Main.dontInlineOtherDexStatic() inliner (before)
+ /// CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Invoke>>]
- // CHECK-START: int Main.dontInlineOtherDexStatic() inliner (after)
- // CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Invoke>>]
+ /// CHECK-START: int Main.dontInlineOtherDexStatic() inliner (after)
+ /// CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Invoke>>]
public static int dontInlineOtherDexStatic() {
return OtherDex.returnOtherDexStatic();
}
- // CHECK-START: int Main.inlineMainStatic() inliner (before)
- // CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Invoke>>]
+ /// CHECK-START: int Main.inlineMainStatic() inliner (before)
+ /// CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Invoke>>]
- // CHECK-START: int Main.inlineMainStatic() inliner (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: int Main.inlineMainStatic() inliner (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
- // CHECK-START: int Main.inlineMainStatic() inliner (after)
- // CHECK-DAG: <<Static:i\d+>> StaticFieldGet
- // CHECK-DAG: Return [<<Static>>]
+ /// CHECK-START: int Main.inlineMainStatic() inliner (after)
+ /// CHECK-DAG: <<Static:i\d+>> StaticFieldGet
+ /// CHECK-DAG: Return [<<Static>>]
public static int inlineMainStatic() {
return OtherDex.returnMainStatic();
}
- // CHECK-START: int Main.dontInlineRecursiveCall() inliner (before)
- // CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Invoke>>]
+ /// CHECK-START: int Main.dontInlineRecursiveCall() inliner (before)
+ /// CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Invoke>>]
- // CHECK-START: int Main.dontInlineRecursiveCall() inliner (after)
- // CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Invoke>>]
+ /// CHECK-START: int Main.dontInlineRecursiveCall() inliner (after)
+ /// CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Invoke>>]
public static int dontInlineRecursiveCall() {
return OtherDex.recursiveCall();
}
- // CHECK-START: java.lang.String Main.dontInlineReturnString() inliner (before)
- // CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Invoke>>]
+ /// CHECK-START: java.lang.String Main.dontInlineReturnString() inliner (before)
+ /// CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Invoke>>]
- // CHECK-START: java.lang.String Main.dontInlineReturnString() inliner (after)
- // CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Invoke>>]
+ /// CHECK-START: java.lang.String Main.dontInlineReturnString() inliner (after)
+ /// CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Invoke>>]
public static String dontInlineReturnString() {
return OtherDex.returnString();
}
- // CHECK-START: java.lang.Class Main.dontInlineOtherDexClass() inliner (before)
- // CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Invoke>>]
+ /// CHECK-START: java.lang.Class Main.dontInlineOtherDexClass() inliner (before)
+ /// CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Invoke>>]
- // CHECK-START: java.lang.Class Main.dontInlineOtherDexClass() inliner (after)
- // CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Invoke>>]
+ /// CHECK-START: java.lang.Class Main.dontInlineOtherDexClass() inliner (after)
+ /// CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Invoke>>]
public static Class dontInlineOtherDexClass() {
return OtherDex.returnOtherDexClass();
}
- // CHECK-START: java.lang.Class Main.inlineMainClass() inliner (before)
- // CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Invoke>>]
+ /// CHECK-START: java.lang.Class Main.inlineMainClass() inliner (before)
+ /// CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Invoke>>]
- // CHECK-START: java.lang.Class Main.inlineMainClass() inliner (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: java.lang.Class Main.inlineMainClass() inliner (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
- // CHECK-START: java.lang.Class Main.inlineMainClass() inliner (after)
- // CHECK-DAG: Return [<<Class:l\d+>>]
- // CHECK-DAG: <<Class>> LoadClass
+ /// CHECK-START: java.lang.Class Main.inlineMainClass() inliner (after)
+ /// CHECK-DAG: Return [<<Class:l\d+>>]
+ /// CHECK-DAG: <<Class>> LoadClass
// Note: There are two LoadClass instructions. We obtain the correct
// instruction id by matching the Return's input list first.
@@ -127,28 +127,28 @@
return OtherDex.returnMainClass();
}
- // CHECK-START: java.lang.Class Main.dontInlineOtherDexClassStaticCall() inliner (before)
- // CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Invoke>>]
+ /// CHECK-START: java.lang.Class Main.dontInlineOtherDexClassStaticCall() inliner (before)
+ /// CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Invoke>>]
- // CHECK-START: java.lang.Class Main.dontInlineOtherDexClassStaticCall() inliner (after)
- // CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Invoke>>]
+ /// CHECK-START: java.lang.Class Main.dontInlineOtherDexClassStaticCall() inliner (after)
+ /// CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Invoke>>]
public static Class dontInlineOtherDexClassStaticCall() {
return OtherDex.returnOtherDexClassStaticCall();
}
- // CHECK-START: java.lang.Class Main.inlineOtherDexCallingMain() inliner (before)
- // CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Invoke>>]
+ /// CHECK-START: java.lang.Class Main.inlineOtherDexCallingMain() inliner (before)
+ /// CHECK-DAG: <<Invoke:l\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Invoke>>]
- // CHECK-START: java.lang.Class Main.inlineOtherDexCallingMain() inliner (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: java.lang.Class Main.inlineOtherDexCallingMain() inliner (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
- // CHECK-START: java.lang.Class Main.inlineOtherDexCallingMain() inliner (after)
- // CHECK-DAG: Return [<<Class:l\d+>>]
- // CHECK-DAG: <<Class>> LoadClass
+ /// CHECK-START: java.lang.Class Main.inlineOtherDexCallingMain() inliner (after)
+ /// CHECK-DAG: Return [<<Class:l\d+>>]
+ /// CHECK-DAG: <<Class>> LoadClass
// Note: There are two LoadClass instructions. We obtain the correct
// instruction id by matching the Return's input list first.
diff --git a/test/463-checker-boolean-simplifier/src/Main.java b/test/463-checker-boolean-simplifier/src/Main.java
index e237448..0b75930 100644
--- a/test/463-checker-boolean-simplifier/src/Main.java
+++ b/test/463-checker-boolean-simplifier/src/Main.java
@@ -37,33 +37,33 @@
* empty branches removed.
*/
- // CHECK-START: boolean Main.BooleanNot(boolean) boolean_simplifier (before)
- // CHECK-DAG: <<Param:z\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: If [<<Param>>]
- // CHECK-DAG: <<Phi:i\d+>> Phi [<<Const1>>,<<Const0>>]
- // CHECK-DAG: Return [<<Phi>>]
+ /// CHECK-START: boolean Main.BooleanNot(boolean) boolean_simplifier (before)
+ /// CHECK-DAG: <<Param:z\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: If [<<Param>>]
+ /// CHECK-DAG: <<Phi:i\d+>> Phi [<<Const1>>,<<Const0>>]
+ /// CHECK-DAG: Return [<<Phi>>]
- // CHECK-START: boolean Main.BooleanNot(boolean) boolean_simplifier (before)
- // CHECK: Goto
- // CHECK: Goto
- // CHECK: Goto
- // CHECK-NOT: Goto
+ /// CHECK-START: boolean Main.BooleanNot(boolean) boolean_simplifier (before)
+ /// CHECK: Goto
+ /// CHECK: Goto
+ /// CHECK: Goto
+ /// CHECK-NOT: Goto
- // CHECK-START: boolean Main.BooleanNot(boolean) boolean_simplifier (after)
- // CHECK-DAG: <<Param:z\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<NotParam:z\d+>> BooleanNot [<<Param>>]
- // CHECK-DAG: Return [<<NotParam>>]
+ /// CHECK-START: boolean Main.BooleanNot(boolean) boolean_simplifier (after)
+ /// CHECK-DAG: <<Param:z\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<NotParam:z\d+>> BooleanNot [<<Param>>]
+ /// CHECK-DAG: Return [<<NotParam>>]
- // CHECK-START: boolean Main.BooleanNot(boolean) boolean_simplifier (after)
- // CHECK-NOT: If
- // CHECK-NOT: Phi
+ /// CHECK-START: boolean Main.BooleanNot(boolean) boolean_simplifier (after)
+ /// CHECK-NOT: If
+ /// CHECK-NOT: Phi
- // CHECK-START: boolean Main.BooleanNot(boolean) boolean_simplifier (after)
- // CHECK: Goto
- // CHECK-NOT: Goto
+ /// CHECK-START: boolean Main.BooleanNot(boolean) boolean_simplifier (after)
+ /// CHECK: Goto
+ /// CHECK-NOT: Goto
public static boolean BooleanNot(boolean x) {
return !x;
@@ -74,23 +74,23 @@
* and 0 when False.
*/
- // CHECK-START: boolean Main.GreaterThan(int, int) boolean_simplifier (before)
- // CHECK-DAG: <<ParamX:i\d+>> ParameterValue
- // CHECK-DAG: <<ParamY:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: <<Cond:z\d+>> GreaterThan [<<ParamX>>,<<ParamY>>]
- // CHECK-DAG: If [<<Cond>>]
- // CHECK-DAG: <<Phi:i\d+>> Phi [<<Const0>>,<<Const1>>]
- // CHECK-DAG: Return [<<Phi>>]
+ /// CHECK-START: boolean Main.GreaterThan(int, int) boolean_simplifier (before)
+ /// CHECK-DAG: <<ParamX:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ParamY:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<Cond:z\d+>> GreaterThan [<<ParamX>>,<<ParamY>>]
+ /// CHECK-DAG: If [<<Cond>>]
+ /// CHECK-DAG: <<Phi:i\d+>> Phi [<<Const0>>,<<Const1>>]
+ /// CHECK-DAG: Return [<<Phi>>]
- // CHECK-START: boolean Main.GreaterThan(int, int) boolean_simplifier (after)
- // CHECK-DAG: <<ParamX:i\d+>> ParameterValue
- // CHECK-DAG: <<ParamY:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: <<Cond:z\d+>> GreaterThan [<<ParamX>>,<<ParamY>>]
- // CHECK-DAG: Return [<<Cond>>]
+ /// CHECK-START: boolean Main.GreaterThan(int, int) boolean_simplifier (after)
+ /// CHECK-DAG: <<ParamX:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ParamY:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<Cond:z\d+>> GreaterThan [<<ParamX>>,<<ParamY>>]
+ /// CHECK-DAG: Return [<<Cond>>]
public static boolean GreaterThan(int x, int y) {
return (x <= y) ? false : true;
@@ -101,26 +101,26 @@
* and 1 when False.
*/
- // CHECK-START: boolean Main.LessThan(int, int) boolean_simplifier (before)
- // CHECK-DAG: <<ParamX:i\d+>> ParameterValue
- // CHECK-DAG: <<ParamY:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: <<Cond:z\d+>> GreaterThanOrEqual [<<ParamX>>,<<ParamY>>]
- // CHECK-DAG: If [<<Cond>>]
- // CHECK-DAG: <<Phi:i\d+>> Phi [<<Const1>>,<<Const0>>]
- // CHECK-DAG: Return [<<Phi>>]
+ /// CHECK-START: boolean Main.LessThan(int, int) boolean_simplifier (before)
+ /// CHECK-DAG: <<ParamX:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ParamY:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<Cond:z\d+>> GreaterThanOrEqual [<<ParamX>>,<<ParamY>>]
+ /// CHECK-DAG: If [<<Cond>>]
+ /// CHECK-DAG: <<Phi:i\d+>> Phi [<<Const1>>,<<Const0>>]
+ /// CHECK-DAG: Return [<<Phi>>]
- // CHECK-START: boolean Main.LessThan(int, int) boolean_simplifier (after)
- // CHECK-DAG: <<ParamX:i\d+>> ParameterValue
- // CHECK-DAG: <<ParamY:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: <<Cond:z\d+>> LessThan [<<ParamX>>,<<ParamY>>]
- // CHECK-DAG: Return [<<Cond>>]
+ /// CHECK-START: boolean Main.LessThan(int, int) boolean_simplifier (after)
+ /// CHECK-DAG: <<ParamX:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ParamY:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<Cond:z\d+>> LessThan [<<ParamX>>,<<ParamY>>]
+ /// CHECK-DAG: Return [<<Cond>>]
- // CHECK-START: boolean Main.LessThan(int, int) boolean_simplifier (after)
- // CHECK-NOT: GreaterThanOrEqual
+ /// CHECK-START: boolean Main.LessThan(int, int) boolean_simplifier (after)
+ /// CHECK-NOT: GreaterThanOrEqual
public static boolean LessThan(int x, int y) {
return (x < y) ? true : false;
@@ -131,57 +131,57 @@
* Note that Phis are discovered retrospectively.
*/
- // CHECK-START: boolean Main.ValuesOrdered(int, int, int) boolean_simplifier (before)
- // CHECK-DAG: <<ParamX:i\d+>> ParameterValue
- // CHECK-DAG: <<ParamY:i\d+>> ParameterValue
- // CHECK-DAG: <<ParamZ:i\d+>> ParameterValue
- // CHECK-DAG: <<Const0:i\d+>> IntConstant 0
- // CHECK-DAG: <<Const1:i\d+>> IntConstant 1
- // CHECK-DAG: <<CondXY:z\d+>> GreaterThan [<<ParamX>>,<<ParamY>>]
- // CHECK-DAG: If [<<CondXY>>]
- // CHECK-DAG: <<CondYZ:z\d+>> GreaterThan [<<ParamY>>,<<ParamZ>>]
- // CHECK-DAG: If [<<CondYZ>>]
- // CHECK-DAG: <<CondXYZ:z\d+>> NotEqual [<<PhiXY:i\d+>>,<<PhiYZ:i\d+>>]
- // CHECK-DAG: If [<<CondXYZ>>]
- // CHECK-DAG: Return [<<PhiXYZ:i\d+>>]
- // CHECK-DAG: <<PhiXY>> Phi [<<Const1>>,<<Const0>>]
- // CHECK-DAG: <<PhiYZ>> Phi [<<Const1>>,<<Const0>>]
- // CHECK-DAG: <<PhiXYZ>> Phi [<<Const1>>,<<Const0>>]
+ /// CHECK-START: boolean Main.ValuesOrdered(int, int, int) boolean_simplifier (before)
+ /// CHECK-DAG: <<ParamX:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ParamY:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ParamZ:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<CondXY:z\d+>> GreaterThan [<<ParamX>>,<<ParamY>>]
+ /// CHECK-DAG: If [<<CondXY>>]
+ /// CHECK-DAG: <<CondYZ:z\d+>> GreaterThan [<<ParamY>>,<<ParamZ>>]
+ /// CHECK-DAG: If [<<CondYZ>>]
+ /// CHECK-DAG: <<CondXYZ:z\d+>> NotEqual [<<PhiXY:i\d+>>,<<PhiYZ:i\d+>>]
+ /// CHECK-DAG: If [<<CondXYZ>>]
+ /// CHECK-DAG: Return [<<PhiXYZ:i\d+>>]
+ /// CHECK-DAG: <<PhiXY>> Phi [<<Const1>>,<<Const0>>]
+ /// CHECK-DAG: <<PhiYZ>> Phi [<<Const1>>,<<Const0>>]
+ /// CHECK-DAG: <<PhiXYZ>> Phi [<<Const1>>,<<Const0>>]
- // CHECK-START: boolean Main.ValuesOrdered(int, int, int) boolean_simplifier (after)
- // CHECK-DAG: <<ParamX:i\d+>> ParameterValue
- // CHECK-DAG: <<ParamY:i\d+>> ParameterValue
- // CHECK-DAG: <<ParamZ:i\d+>> ParameterValue
- // CHECK-DAG: <<CmpXY:z\d+>> LessThanOrEqual [<<ParamX>>,<<ParamY>>]
- // CHECK-DAG: <<CmpYZ:z\d+>> LessThanOrEqual [<<ParamY>>,<<ParamZ>>]
- // CHECK-DAG: <<CmpXYZ:z\d+>> Equal [<<CmpXY>>,<<CmpYZ>>]
- // CHECK-DAG: Return [<<CmpXYZ>>]
+ /// CHECK-START: boolean Main.ValuesOrdered(int, int, int) boolean_simplifier (after)
+ /// CHECK-DAG: <<ParamX:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ParamY:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ParamZ:i\d+>> ParameterValue
+ /// CHECK-DAG: <<CmpXY:z\d+>> LessThanOrEqual [<<ParamX>>,<<ParamY>>]
+ /// CHECK-DAG: <<CmpYZ:z\d+>> LessThanOrEqual [<<ParamY>>,<<ParamZ>>]
+ /// CHECK-DAG: <<CmpXYZ:z\d+>> Equal [<<CmpXY>>,<<CmpYZ>>]
+ /// CHECK-DAG: Return [<<CmpXYZ>>]
public static boolean ValuesOrdered(int x, int y, int z) {
return (x <= y) == (y <= z);
}
- // CHECK-START: int Main.NegatedCondition(boolean) boolean_simplifier (before)
- // CHECK-DAG: <<Param:z\d+>> ParameterValue
- // CHECK-DAG: <<Const42:i\d+>> IntConstant 42
- // CHECK-DAG: <<Const43:i\d+>> IntConstant 43
- // CHECK-DAG: <<NotParam:z\d+>> BooleanNot [<<Param>>]
- // CHECK-DAG: If [<<NotParam>>]
- // CHECK-DAG: <<Phi:i\d+>> Phi [<<Const42>>,<<Const43>>]
- // CHECK-DAG: Return [<<Phi>>]
+ /// CHECK-START: int Main.NegatedCondition(boolean) boolean_simplifier (before)
+ /// CHECK-DAG: <<Param:z\d+>> ParameterValue
+ /// CHECK-DAG: <<Const42:i\d+>> IntConstant 42
+ /// CHECK-DAG: <<Const43:i\d+>> IntConstant 43
+ /// CHECK-DAG: <<NotParam:z\d+>> BooleanNot [<<Param>>]
+ /// CHECK-DAG: If [<<NotParam>>]
+ /// CHECK-DAG: <<Phi:i\d+>> Phi [<<Const42>>,<<Const43>>]
+ /// CHECK-DAG: Return [<<Phi>>]
- // CHECK-START: int Main.NegatedCondition(boolean) boolean_simplifier (after)
- // CHECK-DAG: <<Param:z\d+>> ParameterValue
- // CHECK-DAG: <<Const42:i\d+>> IntConstant 42
- // CHECK-DAG: <<Const43:i\d+>> IntConstant 43
- // CHECK-DAG: If [<<Param>>]
- // CHECK-DAG: <<Phi:i\d+>> Phi [<<Const42>>,<<Const43>>]
- // CHECK-DAG: Return [<<Phi>>]
+ /// CHECK-START: int Main.NegatedCondition(boolean) boolean_simplifier (after)
+ /// CHECK-DAG: <<Param:z\d+>> ParameterValue
+ /// CHECK-DAG: <<Const42:i\d+>> IntConstant 42
+ /// CHECK-DAG: <<Const43:i\d+>> IntConstant 43
+ /// CHECK-DAG: If [<<Param>>]
+ /// CHECK-DAG: <<Phi:i\d+>> Phi [<<Const42>>,<<Const43>>]
+ /// CHECK-DAG: Return [<<Phi>>]
// Note: The fact that branches are swapped is verified by running the test.
- // CHECK-START: int Main.NegatedCondition(boolean) boolean_simplifier (after)
- // CHECK-NOT: BooleanNot
+ /// CHECK-START: int Main.NegatedCondition(boolean) boolean_simplifier (after)
+ /// CHECK-NOT: BooleanNot
public static int NegatedCondition(boolean x) {
if (x != false) {
diff --git a/test/464-checker-inline-sharpen-calls/src/Main.java b/test/464-checker-inline-sharpen-calls/src/Main.java
index e451f70..876496f 100644
--- a/test/464-checker-inline-sharpen-calls/src/Main.java
+++ b/test/464-checker-inline-sharpen-calls/src/Main.java
@@ -19,27 +19,27 @@
public void invokeVirtual() {
}
- // CHECK-START: void Main.inlineSharpenInvokeVirtual(Main) inliner (before)
- // CHECK-DAG: <<Invoke:v\d+>> InvokeStaticOrDirect
- // CHECK-DAG: ReturnVoid
+ /// CHECK-START: void Main.inlineSharpenInvokeVirtual(Main) inliner (before)
+ /// CHECK-DAG: <<Invoke:v\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: ReturnVoid
- // CHECK-START: void Main.inlineSharpenInvokeVirtual(Main) inliner (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: void Main.inlineSharpenInvokeVirtual(Main) inliner (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
public static void inlineSharpenInvokeVirtual(Main m) {
m.invokeVirtual();
}
- // CHECK-START: int Main.inlineSharpenStringInvoke() inliner (before)
- // CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
- // CHECK-DAG: Return [<<Invoke>>]
+ /// CHECK-START: int Main.inlineSharpenStringInvoke() inliner (before)
+ /// CHECK-DAG: <<Invoke:i\d+>> InvokeStaticOrDirect
+ /// CHECK-DAG: Return [<<Invoke>>]
- // CHECK-START: int Main.inlineSharpenStringInvoke() inliner (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: int Main.inlineSharpenStringInvoke() inliner (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
- // CHECK-START: int Main.inlineSharpenStringInvoke() inliner (after)
- // CHECK-DAG: <<Field:i\d+>> InstanceFieldGet
- // CHECK-DAG: Return [<<Field>>]
+ /// CHECK-START: int Main.inlineSharpenStringInvoke() inliner (after)
+ /// CHECK-DAG: <<Field:i\d+>> InstanceFieldGet
+ /// CHECK-DAG: Return [<<Field>>]
public static int inlineSharpenStringInvoke() {
return "Foo".length();
diff --git a/test/465-checker-clinit-gvn/src/Main.java b/test/465-checker-clinit-gvn/src/Main.java
index ac2863c..704e9fe 100644
--- a/test/465-checker-clinit-gvn/src/Main.java
+++ b/test/465-checker-clinit-gvn/src/Main.java
@@ -26,31 +26,31 @@
public final class Main {
- // CHECK-START: int Main.accessTwoStatics() GVN (before)
- // CHECK-DAG: <<Class1:l\d+>> LoadClass
- // CHECK-DAG: ClinitCheck [<<Class1>>]
- // CHECK-DAG: <<Class2:l\d+>> LoadClass
- // CHECK-DAG: ClinitCheck [<<Class2>>]
+ /// CHECK-START: int Main.accessTwoStatics() GVN (before)
+ /// CHECK-DAG: <<Class1:l\d+>> LoadClass
+ /// CHECK-DAG: ClinitCheck [<<Class1>>]
+ /// CHECK-DAG: <<Class2:l\d+>> LoadClass
+ /// CHECK-DAG: ClinitCheck [<<Class2>>]
- // CHECK-START: int Main.accessTwoStatics() GVN (after)
- // CHECK-DAG: <<Class:l\d+>> LoadClass
- // CHECK-DAG: ClinitCheck [<<Class>>]
- // CHECK-NOT: ClinitCheck
+ /// CHECK-START: int Main.accessTwoStatics() GVN (after)
+ /// CHECK-DAG: <<Class:l\d+>> LoadClass
+ /// CHECK-DAG: ClinitCheck [<<Class>>]
+ /// CHECK-NOT: ClinitCheck
public static int accessTwoStatics() {
return OtherClass.b - OtherClass.a;
}
- // CHECK-START: int Main.accessTwoStaticsCallInBetween() GVN (before)
- // CHECK-DAG: <<Class1:l\d+>> LoadClass
- // CHECK-DAG: ClinitCheck [<<Class1>>]
- // CHECK-DAG: <<Class2:l\d+>> LoadClass
- // CHECK-DAG: ClinitCheck [<<Class2>>]
+ /// CHECK-START: int Main.accessTwoStaticsCallInBetween() GVN (before)
+ /// CHECK-DAG: <<Class1:l\d+>> LoadClass
+ /// CHECK-DAG: ClinitCheck [<<Class1>>]
+ /// CHECK-DAG: <<Class2:l\d+>> LoadClass
+ /// CHECK-DAG: ClinitCheck [<<Class2>>]
- // CHECK-START: int Main.accessTwoStaticsCallInBetween() GVN (after)
- // CHECK-DAG: <<Class:l\d+>> LoadClass
- // CHECK-DAG: ClinitCheck [<<Class>>]
- // CHECK-NOT: ClinitCheck
+ /// CHECK-START: int Main.accessTwoStaticsCallInBetween() GVN (after)
+ /// CHECK-DAG: <<Class:l\d+>> LoadClass
+ /// CHECK-DAG: ClinitCheck [<<Class>>]
+ /// CHECK-NOT: ClinitCheck
public static int accessTwoStaticsCallInBetween() {
int b = OtherClass.b;
diff --git a/test/468-checker-bool-simplifier-regression/smali/TestCase.smali b/test/468-checker-bool-simplifier-regression/smali/TestCase.smali
index 33e6dc3..da1c5ec 100644
--- a/test/468-checker-bool-simplifier-regression/smali/TestCase.smali
+++ b/test/468-checker-bool-simplifier-regression/smali/TestCase.smali
@@ -18,18 +18,18 @@
.field public static value:Z
-# CHECK-START: boolean TestCase.testCase() boolean_simplifier (before)
-# CHECK-DAG: <<Const0:i\d+>> IntConstant 0
-# CHECK-DAG: <<Const1:i\d+>> IntConstant 1
-# CHECK-DAG: <<Value:z\d+>> StaticFieldGet
-# CHECK-DAG: If [<<Value>>]
-# CHECK-DAG: <<Phi:i\d+>> Phi [<<Const1>>,<<Const0>>]
-# CHECK-DAG: Return [<<Phi>>]
+## CHECK-START: boolean TestCase.testCase() boolean_simplifier (before)
+## CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+## CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+## CHECK-DAG: <<Value:z\d+>> StaticFieldGet
+## CHECK-DAG: If [<<Value>>]
+## CHECK-DAG: <<Phi:i\d+>> Phi [<<Const1>>,<<Const0>>]
+## CHECK-DAG: Return [<<Phi>>]
-# CHECK-START: boolean TestCase.testCase() boolean_simplifier (after)
-# CHECK-DAG: <<Value:z\d+>> StaticFieldGet
-# CHECK-DAG: <<Not:z\d+>> BooleanNot [<<Value>>]
-# CHECK-DAG: Return [<<Not>>]
+## CHECK-START: boolean TestCase.testCase() boolean_simplifier (after)
+## CHECK-DAG: <<Value:z\d+>> StaticFieldGet
+## CHECK-DAG: <<Not:z\d+>> BooleanNot [<<Value>>]
+## CHECK-DAG: Return [<<Not>>]
.method public static testCase()Z
.registers 2
diff --git a/test/473-checker-inliner-constants/src/Main.java b/test/473-checker-inliner-constants/src/Main.java
index 79d89b0..85f6565 100644
--- a/test/473-checker-inliner-constants/src/Main.java
+++ b/test/473-checker-inliner-constants/src/Main.java
@@ -16,13 +16,13 @@
public class Main {
- // CHECK-START: java.lang.Object Main.InlineNullConstant() inliner (before)
- // CHECK: NullConstant
- // CHECK-NOT: NullConstant
+ /// CHECK-START: java.lang.Object Main.InlineNullConstant() inliner (before)
+ /// CHECK: NullConstant
+ /// CHECK-NOT: NullConstant
- // CHECK-START: java.lang.Object Main.InlineNullConstant() inliner (after)
- // CHECK: NullConstant
- // CHECK-NOT: NullConstant
+ /// CHECK-START: java.lang.Object Main.InlineNullConstant() inliner (after)
+ /// CHECK: NullConstant
+ /// CHECK-NOT: NullConstant
public static Object returnNullConstant(Object x) {
return null;
@@ -32,13 +32,13 @@
return returnNullConstant(null);
}
- // CHECK-START: int Main.InlineIntConstant() inliner (before)
- // CHECK: IntConstant 42
- // CHECK-NOT: IntConstant 42
+ /// CHECK-START: int Main.InlineIntConstant() inliner (before)
+ /// CHECK: IntConstant 42
+ /// CHECK-NOT: IntConstant 42
- // CHECK-START: int Main.InlineIntConstant() inliner (after)
- // CHECK: IntConstant 42
- // CHECK-NOT: IntConstant 42
+ /// CHECK-START: int Main.InlineIntConstant() inliner (after)
+ /// CHECK: IntConstant 42
+ /// CHECK-NOT: IntConstant 42
public static int returnIntConstant(int x) {
return 42;
@@ -48,13 +48,13 @@
return returnIntConstant(42);
}
- // CHECK-START: long Main.InlineLongConstant() inliner (before)
- // CHECK: LongConstant 42
- // CHECK-NOT: LongConstant 42
+ /// CHECK-START: long Main.InlineLongConstant() inliner (before)
+ /// CHECK: LongConstant 42
+ /// CHECK-NOT: LongConstant 42
- // CHECK-START: long Main.InlineLongConstant() inliner (after)
- // CHECK: LongConstant 42
- // CHECK-NOT: LongConstant 42
+ /// CHECK-START: long Main.InlineLongConstant() inliner (after)
+ /// CHECK: LongConstant 42
+ /// CHECK-NOT: LongConstant 42
public static long returnLongConstant(long x) {
return 42L;
diff --git a/test/474-checker-boolean-input/src/Main.java b/test/474-checker-boolean-input/src/Main.java
index 490f7f9..86d0f7c 100644
--- a/test/474-checker-boolean-input/src/Main.java
+++ b/test/474-checker-boolean-input/src/Main.java
@@ -27,9 +27,9 @@
* we implement a suitable type analysis.
*/
- // CHECK-START: boolean Main.TestPhiAsBoolean(int) boolean_simplifier (after)
- // CHECK-DAG: <<Phi:i\d+>> Phi
- // CHECK-DAG: BooleanNot [<<Phi>>]
+ /// CHECK-START: boolean Main.TestPhiAsBoolean(int) boolean_simplifier (after)
+ /// CHECK-DAG: <<Phi:i\d+>> Phi
+ /// CHECK-DAG: BooleanNot [<<Phi>>]
public static boolean f1;
public static boolean f2;
@@ -47,9 +47,9 @@
* we implement a suitable type analysis.
*/
- // CHECK-START: boolean Main.TestAndAsBoolean(boolean, boolean) boolean_simplifier (after)
- // CHECK-DAG: <<And:i\d+>> And
- // CHECK-DAG: BooleanNot [<<And>>]
+ /// CHECK-START: boolean Main.TestAndAsBoolean(boolean, boolean) boolean_simplifier (after)
+ /// CHECK-DAG: <<And:i\d+>> And
+ /// CHECK-DAG: BooleanNot [<<And>>]
public static boolean InlineAnd(boolean x, boolean y) {
return x & y;
@@ -64,9 +64,9 @@
* we implement a suitable type analysis.
*/
- // CHECK-START: boolean Main.TestOrAsBoolean(boolean, boolean) boolean_simplifier (after)
- // CHECK-DAG: <<Or:i\d+>> Or
- // CHECK-DAG: BooleanNot [<<Or>>]
+ /// CHECK-START: boolean Main.TestOrAsBoolean(boolean, boolean) boolean_simplifier (after)
+ /// CHECK-DAG: <<Or:i\d+>> Or
+ /// CHECK-DAG: BooleanNot [<<Or>>]
public static boolean InlineOr(boolean x, boolean y) {
return x | y;
@@ -81,9 +81,9 @@
* we implement a suitable type analysis.
*/
- // CHECK-START: boolean Main.TestXorAsBoolean(boolean, boolean) boolean_simplifier (after)
- // CHECK-DAG: <<Xor:i\d+>> Xor
- // CHECK-DAG: BooleanNot [<<Xor>>]
+ /// CHECK-START: boolean Main.TestXorAsBoolean(boolean, boolean) boolean_simplifier (after)
+ /// CHECK-DAG: <<Xor:i\d+>> Xor
+ /// CHECK-DAG: BooleanNot [<<Xor>>]
public static boolean InlineXor(boolean x, boolean y) {
return x ^ y;
diff --git a/test/476-checker-ctor-memory-barrier/src/Main.java b/test/476-checker-ctor-memory-barrier/src/Main.java
index f24dc4a..e709ba0 100644
--- a/test/476-checker-ctor-memory-barrier/src/Main.java
+++ b/test/476-checker-ctor-memory-barrier/src/Main.java
@@ -17,8 +17,8 @@
// TODO: Add more tests after we can inline functions with calls.
class ClassWithoutFinals {
- // CHECK-START: void ClassWithoutFinals.<init>() register (after)
- // CHECK-NOT: MemoryBarrier kind:StoreStore
+ /// CHECK-START: void ClassWithoutFinals.<init>() register (after)
+ /// CHECK-NOT: MemoryBarrier kind:StoreStore
public ClassWithoutFinals() {}
}
@@ -26,9 +26,9 @@
public final int x;
public ClassWithFinals obj;
- // CHECK-START: void ClassWithFinals.<init>(boolean) register (after)
- // CHECK: MemoryBarrier kind:StoreStore
- // CHECK-NEXT: ReturnVoid
+ /// CHECK-START: void ClassWithFinals.<init>(boolean) register (after)
+ /// CHECK: MemoryBarrier kind:StoreStore
+ /// CHECK-NEXT: ReturnVoid
public ClassWithFinals(boolean cond) {
x = 0;
if (cond) {
@@ -37,17 +37,17 @@
}
}
- // CHECK-START: void ClassWithFinals.<init>() register (after)
- // CHECK: MemoryBarrier kind:StoreStore
- // CHECK-NEXT: ReturnVoid
+ /// CHECK-START: void ClassWithFinals.<init>() register (after)
+ /// CHECK: MemoryBarrier kind:StoreStore
+ /// CHECK-NEXT: ReturnVoid
public ClassWithFinals() {
x = 0;
}
- // CHECK-START: void ClassWithFinals.<init>(int) register (after)
- // CHECK: MemoryBarrier kind:StoreStore
- // CHECK: MemoryBarrier kind:StoreStore
- // CHECK-NEXT: ReturnVoid
+ /// CHECK-START: void ClassWithFinals.<init>(int) register (after)
+ /// CHECK: MemoryBarrier kind:StoreStore
+ /// CHECK: MemoryBarrier kind:StoreStore
+ /// CHECK-NEXT: ReturnVoid
public ClassWithFinals(int x) {
// This should have two barriers:
// - one for the constructor
@@ -58,33 +58,33 @@
}
class InheritFromClassWithFinals extends ClassWithFinals {
- // CHECK-START: void InheritFromClassWithFinals.<init>() register (after)
- // CHECK: MemoryBarrier kind:StoreStore
- // CHECK-NEXT: ReturnVoid
+ /// CHECK-START: void InheritFromClassWithFinals.<init>() register (after)
+ /// CHECK: MemoryBarrier kind:StoreStore
+ /// CHECK-NEXT: ReturnVoid
- // CHECK-START: void InheritFromClassWithFinals.<init>() register (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: void InheritFromClassWithFinals.<init>() register (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
public InheritFromClassWithFinals() {
// Should inline the super constructor.
}
- // CHECK-START: void InheritFromClassWithFinals.<init>(boolean) register (after)
- // CHECK: InvokeStaticOrDirect
+ /// CHECK-START: void InheritFromClassWithFinals.<init>(boolean) register (after)
+ /// CHECK: InvokeStaticOrDirect
- // CHECK-START: void InheritFromClassWithFinals.<init>(boolean) register (after)
- // CHECK-NOT: MemoryBarrier kind:StoreStore
+ /// CHECK-START: void InheritFromClassWithFinals.<init>(boolean) register (after)
+ /// CHECK-NOT: MemoryBarrier kind:StoreStore
public InheritFromClassWithFinals(boolean cond) {
super(cond);
// should not inline the super constructor
}
- // CHECK-START: void InheritFromClassWithFinals.<init>(int) register (after)
- // CHECK: MemoryBarrier kind:StoreStore
- // CHECK: MemoryBarrier kind:StoreStore
- // CHECK: ReturnVoid
+ /// CHECK-START: void InheritFromClassWithFinals.<init>(int) register (after)
+ /// CHECK: MemoryBarrier kind:StoreStore
+ /// CHECK: MemoryBarrier kind:StoreStore
+ /// CHECK: ReturnVoid
- // CHECK-START: void InheritFromClassWithFinals.<init>(int) register (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: void InheritFromClassWithFinals.<init>(int) register (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
public InheritFromClassWithFinals(int unused) {
// Should inline the super constructor and insert a memory barrier.
@@ -96,35 +96,35 @@
class HaveFinalsAndInheritFromClassWithFinals extends ClassWithFinals {
final int y;
- // CHECK-START: void HaveFinalsAndInheritFromClassWithFinals.<init>() register (after)
- // CHECK: MemoryBarrier kind:StoreStore
- // CHECK-NEXT: ReturnVoid
+ /// CHECK-START: void HaveFinalsAndInheritFromClassWithFinals.<init>() register (after)
+ /// CHECK: MemoryBarrier kind:StoreStore
+ /// CHECK-NEXT: ReturnVoid
- // CHECK-START: void HaveFinalsAndInheritFromClassWithFinals.<init>() register (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: void HaveFinalsAndInheritFromClassWithFinals.<init>() register (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
public HaveFinalsAndInheritFromClassWithFinals() {
// Should inline the super constructor and remove the memory barrier.
y = 0;
}
- // CHECK-START: void HaveFinalsAndInheritFromClassWithFinals.<init>(boolean) register (after)
- // CHECK: InvokeStaticOrDirect
- // CHECK: MemoryBarrier kind:StoreStore
- // CHECK-NEXT: ReturnVoid
+ /// CHECK-START: void HaveFinalsAndInheritFromClassWithFinals.<init>(boolean) register (after)
+ /// CHECK: InvokeStaticOrDirect
+ /// CHECK: MemoryBarrier kind:StoreStore
+ /// CHECK-NEXT: ReturnVoid
public HaveFinalsAndInheritFromClassWithFinals(boolean cond) {
super(cond);
// should not inline the super constructor
y = 0;
}
- // CHECK-START: void HaveFinalsAndInheritFromClassWithFinals.<init>(int) register (after)
- // CHECK: MemoryBarrier kind:StoreStore
- // CHECK: MemoryBarrier kind:StoreStore
- // CHECK: MemoryBarrier kind:StoreStore
- // CHECK-NEXT: ReturnVoid
+ /// CHECK-START: void HaveFinalsAndInheritFromClassWithFinals.<init>(int) register (after)
+ /// CHECK: MemoryBarrier kind:StoreStore
+ /// CHECK: MemoryBarrier kind:StoreStore
+ /// CHECK: MemoryBarrier kind:StoreStore
+ /// CHECK-NEXT: ReturnVoid
- // CHECK-START: void HaveFinalsAndInheritFromClassWithFinals.<init>(int) register (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: void HaveFinalsAndInheritFromClassWithFinals.<init>(int) register (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
public HaveFinalsAndInheritFromClassWithFinals(int unused) {
// Should inline the super constructor and keep just one memory barrier.
y = 0;
@@ -138,52 +138,52 @@
public class Main {
- // CHECK-START: ClassWithFinals Main.noInlineNoConstructorBarrier() register (after)
- // CHECK: InvokeStaticOrDirect
+ /// CHECK-START: ClassWithFinals Main.noInlineNoConstructorBarrier() register (after)
+ /// CHECK: InvokeStaticOrDirect
- // CHECK-START: ClassWithFinals Main.noInlineNoConstructorBarrier() register (after)
- // CHECK-NOT: MemoryBarrier kind:StoreStore
+ /// CHECK-START: ClassWithFinals Main.noInlineNoConstructorBarrier() register (after)
+ /// CHECK-NOT: MemoryBarrier kind:StoreStore
public static ClassWithFinals noInlineNoConstructorBarrier() {
return new ClassWithFinals(false);
}
- // CHECK-START: void Main.inlineNew() register (after)
- // CHECK: MemoryBarrier kind:StoreStore
- // CHECK-NEXT: ReturnVoid
+ /// CHECK-START: void Main.inlineNew() register (after)
+ /// CHECK: MemoryBarrier kind:StoreStore
+ /// CHECK-NEXT: ReturnVoid
- // CHECK-START: void Main.inlineNew() register (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: void Main.inlineNew() register (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
public static void inlineNew() {
new ClassWithFinals();
}
- // CHECK-START: void Main.inlineNew1() register (after)
- // CHECK: MemoryBarrier kind:StoreStore
- // CHECK-NEXT: ReturnVoid
+ /// CHECK-START: void Main.inlineNew1() register (after)
+ /// CHECK: MemoryBarrier kind:StoreStore
+ /// CHECK-NEXT: ReturnVoid
- // CHECK-START: void Main.inlineNew1() register (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: void Main.inlineNew1() register (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
public static void inlineNew1() {
new InheritFromClassWithFinals();
}
- // CHECK-START: void Main.inlineNew2() register (after)
- // CHECK: MemoryBarrier kind:StoreStore
- // CHECK-NEXT: ReturnVoid
+ /// CHECK-START: void Main.inlineNew2() register (after)
+ /// CHECK: MemoryBarrier kind:StoreStore
+ /// CHECK-NEXT: ReturnVoid
- // CHECK-START: void Main.inlineNew2() register (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: void Main.inlineNew2() register (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
public static void inlineNew2() {
new HaveFinalsAndInheritFromClassWithFinals();
}
- // CHECK-START: void Main.inlineNew3() register (after)
- // CHECK: MemoryBarrier kind:StoreStore
- // CHECK: MemoryBarrier kind:StoreStore
- // CHECK-NEXT: ReturnVoid
+ /// CHECK-START: void Main.inlineNew3() register (after)
+ /// CHECK: MemoryBarrier kind:StoreStore
+ /// CHECK: MemoryBarrier kind:StoreStore
+ /// CHECK-NEXT: ReturnVoid
- // CHECK-START: void Main.inlineNew3() register (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: void Main.inlineNew3() register (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
public static void inlineNew3() {
new HaveFinalsAndInheritFromClassWithFinals();
new HaveFinalsAndInheritFromClassWithFinals();
diff --git a/test/477-checker-bound-type/src/Main.java b/test/477-checker-bound-type/src/Main.java
index b30028d..fe52e83 100644
--- a/test/477-checker-bound-type/src/Main.java
+++ b/test/477-checker-bound-type/src/Main.java
@@ -17,8 +17,8 @@
public class Main {
- // CHECK-START: java.lang.Object Main.boundTypeForIf(java.lang.Object) reference_type_propagation (after)
- // CHECK: BoundType
+ /// CHECK-START: java.lang.Object Main.boundTypeForIf(java.lang.Object) reference_type_propagation (after)
+ /// CHECK: BoundType
public static Object boundTypeForIf(Object a) {
if (a != null) {
return a.toString();
@@ -27,8 +27,8 @@
}
}
- // CHECK-START: java.lang.Object Main.boundTypeForInstanceOf(java.lang.Object) reference_type_propagation (after)
- // CHECK: BoundType
+ /// CHECK-START: java.lang.Object Main.boundTypeForInstanceOf(java.lang.Object) reference_type_propagation (after)
+ /// CHECK: BoundType
public static Object boundTypeForInstanceOf(Object a) {
if (a instanceof Main) {
return (Main)a;
@@ -37,8 +37,8 @@
}
}
- // CHECK-START: java.lang.Object Main.noBoundTypeForIf(java.lang.Object) reference_type_propagation (after)
- // CHECK-NOT: BoundType
+ /// CHECK-START: java.lang.Object Main.noBoundTypeForIf(java.lang.Object) reference_type_propagation (after)
+ /// CHECK-NOT: BoundType
public static Object noBoundTypeForIf(Object a) {
if (a == null) {
return new Object();
@@ -47,8 +47,8 @@
}
}
- // CHECK-START: java.lang.Object Main.noBoundTypeForInstanceOf(java.lang.Object) reference_type_propagation (after)
- // CHECK-NOT: BoundType
+ /// CHECK-START: java.lang.Object Main.noBoundTypeForInstanceOf(java.lang.Object) reference_type_propagation (after)
+ /// CHECK-NOT: BoundType
public static Object noBoundTypeForInstanceOf(Object a) {
if (a instanceof Main) {
return new Object();
diff --git a/test/478-checker-clinit-check-pruning/src/Main.java b/test/478-checker-clinit-check-pruning/src/Main.java
index e8739b8..d5592aa 100644
--- a/test/478-checker-clinit-check-pruning/src/Main.java
+++ b/test/478-checker-clinit-check-pruning/src/Main.java
@@ -23,17 +23,17 @@
* removed before register allocation & code generation.
*/
- // CHECK-START: void Main.invokeStaticInlined() builder (after)
- // CHECK-DAG: <<LoadClass:l\d+>> LoadClass gen_clinit_check:false
- // CHECK-DAG: <<ClinitCheck:l\d+>> ClinitCheck [<<LoadClass>>]
- // CHECK-DAG: InvokeStaticOrDirect [<<ClinitCheck>>]
+ /// CHECK-START: void Main.invokeStaticInlined() builder (after)
+ /// CHECK-DAG: <<LoadClass:l\d+>> LoadClass gen_clinit_check:false
+ /// CHECK-DAG: <<ClinitCheck:l\d+>> ClinitCheck [<<LoadClass>>]
+ /// CHECK-DAG: InvokeStaticOrDirect [<<ClinitCheck>>]
- // CHECK-START: void Main.invokeStaticInlined() inliner (after)
- // CHECK-DAG: <<LoadClass:l\d+>> LoadClass gen_clinit_check:false
- // CHECK-DAG: <<ClinitCheck:l\d+>> ClinitCheck [<<LoadClass>>]
+ /// CHECK-START: void Main.invokeStaticInlined() inliner (after)
+ /// CHECK-DAG: <<LoadClass:l\d+>> LoadClass gen_clinit_check:false
+ /// CHECK-DAG: <<ClinitCheck:l\d+>> ClinitCheck [<<LoadClass>>]
- // CHECK-START: void Main.invokeStaticInlined() inliner (after)
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: void Main.invokeStaticInlined() inliner (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
// The following checks ensure the clinit check instruction added by
// the builder is pruned by the PrepareForRegisterAllocation, while
@@ -41,12 +41,12 @@
// graph is not dumped after (nor before) this step, we check the
// CFG as it is before the next pass (liveness analysis) instead.
- // CHECK-START: void Main.invokeStaticInlined() liveness (before)
- // CHECK-DAG: LoadClass gen_clinit_check:true
+ /// CHECK-START: void Main.invokeStaticInlined() liveness (before)
+ /// CHECK-DAG: LoadClass gen_clinit_check:true
- // CHECK-START: void Main.invokeStaticInlined() liveness (before)
- // CHECK-NOT: ClinitCheck
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: void Main.invokeStaticInlined() liveness (before)
+ /// CHECK-NOT: ClinitCheck
+ /// CHECK-NOT: InvokeStaticOrDirect
static void invokeStaticInlined() {
ClassWithClinit1.$opt$inline$StaticMethod();
@@ -66,15 +66,15 @@
* initialization check of the called method's declaring class.
*/
- // CHECK-START: void Main.invokeStaticNotInlined() builder (after)
- // CHECK-DAG: <<LoadClass:l\d+>> LoadClass gen_clinit_check:false
- // CHECK-DAG: <<ClinitCheck:l\d+>> ClinitCheck [<<LoadClass>>]
- // CHECK-DAG: InvokeStaticOrDirect [<<ClinitCheck>>]
+ /// CHECK-START: void Main.invokeStaticNotInlined() builder (after)
+ /// CHECK-DAG: <<LoadClass:l\d+>> LoadClass gen_clinit_check:false
+ /// CHECK-DAG: <<ClinitCheck:l\d+>> ClinitCheck [<<LoadClass>>]
+ /// CHECK-DAG: InvokeStaticOrDirect [<<ClinitCheck>>]
- // CHECK-START: void Main.invokeStaticNotInlined() inliner (after)
- // CHECK-DAG: <<LoadClass:l\d+>> LoadClass gen_clinit_check:false
- // CHECK-DAG: <<ClinitCheck:l\d+>> ClinitCheck [<<LoadClass>>]
- // CHECK-DAG: InvokeStaticOrDirect [<<ClinitCheck>>]
+ /// CHECK-START: void Main.invokeStaticNotInlined() inliner (after)
+ /// CHECK-DAG: <<LoadClass:l\d+>> LoadClass gen_clinit_check:false
+ /// CHECK-DAG: <<ClinitCheck:l\d+>> ClinitCheck [<<LoadClass>>]
+ /// CHECK-DAG: InvokeStaticOrDirect [<<ClinitCheck>>]
// The following checks ensure the clinit check and load class
// instructions added by the builder are pruned by the
@@ -82,12 +82,12 @@
// dumped after (nor before) this step, we check the CFG as it is
// before the next pass (liveness analysis) instead.
- // CHECK-START: void Main.invokeStaticNotInlined() liveness (before)
- // CHECK-DAG: InvokeStaticOrDirect
+ /// CHECK-START: void Main.invokeStaticNotInlined() liveness (before)
+ /// CHECK-DAG: InvokeStaticOrDirect
- // CHECK-START: void Main.invokeStaticNotInlined() liveness (before)
- // CHECK-NOT: LoadClass
- // CHECK-NOT: ClinitCheck
+ /// CHECK-START: void Main.invokeStaticNotInlined() liveness (before)
+ /// CHECK-NOT: LoadClass
+ /// CHECK-NOT: ClinitCheck
static void invokeStaticNotInlined() {
ClassWithClinit2.staticMethod();
@@ -114,17 +114,17 @@
* explicit clinit check.
*/
- // CHECK-START: void Main$ClassWithClinit3.invokeStaticInlined() builder (after)
- // CHECK-DAG: InvokeStaticOrDirect
+ /// CHECK-START: void Main$ClassWithClinit3.invokeStaticInlined() builder (after)
+ /// CHECK-DAG: InvokeStaticOrDirect
- // CHECK-START: void Main$ClassWithClinit3.invokeStaticInlined() builder (after)
- // CHECK-NOT: LoadClass
- // CHECK-NOT: ClinitCheck
+ /// CHECK-START: void Main$ClassWithClinit3.invokeStaticInlined() builder (after)
+ /// CHECK-NOT: LoadClass
+ /// CHECK-NOT: ClinitCheck
- // CHECK-START: void Main$ClassWithClinit3.invokeStaticInlined() inliner (after)
- // CHECK-NOT: LoadClass
- // CHECK-NOT: ClinitCheck
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: void Main$ClassWithClinit3.invokeStaticInlined() inliner (after)
+ /// CHECK-NOT: LoadClass
+ /// CHECK-NOT: ClinitCheck
+ /// CHECK-NOT: InvokeStaticOrDirect
static class ClassWithClinit3 {
static void invokeStaticInlined() {
@@ -149,19 +149,19 @@
* require an explicit clinit check.
*/
- // CHECK-START: void Main$ClassWithClinit4.invokeStaticNotInlined() builder (after)
- // CHECK-DAG: InvokeStaticOrDirect
+ /// CHECK-START: void Main$ClassWithClinit4.invokeStaticNotInlined() builder (after)
+ /// CHECK-DAG: InvokeStaticOrDirect
- // CHECK-START: void Main$ClassWithClinit4.invokeStaticNotInlined() builder (after)
- // CHECK-NOT: LoadClass
- // CHECK-NOT: ClinitCheck
+ /// CHECK-START: void Main$ClassWithClinit4.invokeStaticNotInlined() builder (after)
+ /// CHECK-NOT: LoadClass
+ /// CHECK-NOT: ClinitCheck
- // CHECK-START: void Main$ClassWithClinit4.invokeStaticNotInlined() inliner (after)
- // CHECK-DAG: InvokeStaticOrDirect
+ /// CHECK-START: void Main$ClassWithClinit4.invokeStaticNotInlined() inliner (after)
+ /// CHECK-DAG: InvokeStaticOrDirect
- // CHECK-START: void Main$ClassWithClinit4.invokeStaticNotInlined() inliner (after)
- // CHECK-NOT: LoadClass
- // CHECK-NOT: ClinitCheck
+ /// CHECK-START: void Main$ClassWithClinit4.invokeStaticNotInlined() inliner (after)
+ /// CHECK-NOT: LoadClass
+ /// CHECK-NOT: ClinitCheck
static class ClassWithClinit4 {
static void invokeStaticNotInlined() {
@@ -192,17 +192,17 @@
* explicit clinit check.
*/
- // CHECK-START: void Main$SubClassOfClassWithClinit5.invokeStaticInlined() builder (after)
- // CHECK-DAG: InvokeStaticOrDirect
+ /// CHECK-START: void Main$SubClassOfClassWithClinit5.invokeStaticInlined() builder (after)
+ /// CHECK-DAG: InvokeStaticOrDirect
- // CHECK-START: void Main$SubClassOfClassWithClinit5.invokeStaticInlined() builder (after)
- // CHECK-NOT: LoadClass
- // CHECK-NOT: ClinitCheck
+ /// CHECK-START: void Main$SubClassOfClassWithClinit5.invokeStaticInlined() builder (after)
+ /// CHECK-NOT: LoadClass
+ /// CHECK-NOT: ClinitCheck
- // CHECK-START: void Main$SubClassOfClassWithClinit5.invokeStaticInlined() inliner (after)
- // CHECK-NOT: LoadClass
- // CHECK-NOT: ClinitCheck
- // CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: void Main$SubClassOfClassWithClinit5.invokeStaticInlined() inliner (after)
+ /// CHECK-NOT: LoadClass
+ /// CHECK-NOT: ClinitCheck
+ /// CHECK-NOT: InvokeStaticOrDirect
static class ClassWithClinit5 {
static void $opt$inline$StaticMethod() {
@@ -225,19 +225,19 @@
* explicit clinit check.
*/
- // CHECK-START: void Main$SubClassOfClassWithClinit6.invokeStaticNotInlined() builder (after)
- // CHECK-DAG: InvokeStaticOrDirect
+ /// CHECK-START: void Main$SubClassOfClassWithClinit6.invokeStaticNotInlined() builder (after)
+ /// CHECK-DAG: InvokeStaticOrDirect
- // CHECK-START: void Main$SubClassOfClassWithClinit6.invokeStaticNotInlined() builder (after)
- // CHECK-NOT: LoadClass
- // CHECK-NOT: ClinitCheck
+ /// CHECK-START: void Main$SubClassOfClassWithClinit6.invokeStaticNotInlined() builder (after)
+ /// CHECK-NOT: LoadClass
+ /// CHECK-NOT: ClinitCheck
- // CHECK-START: void Main$SubClassOfClassWithClinit6.invokeStaticNotInlined() inliner (after)
- // CHECK-DAG: InvokeStaticOrDirect
+ /// CHECK-START: void Main$SubClassOfClassWithClinit6.invokeStaticNotInlined() inliner (after)
+ /// CHECK-DAG: InvokeStaticOrDirect
- // CHECK-START: void Main$SubClassOfClassWithClinit6.invokeStaticNotInlined() inliner (after)
- // CHECK-NOT: LoadClass
- // CHECK-NOT: ClinitCheck
+ /// CHECK-START: void Main$SubClassOfClassWithClinit6.invokeStaticNotInlined() inliner (after)
+ /// CHECK-NOT: LoadClass
+ /// CHECK-NOT: ClinitCheck
static class ClassWithClinit6 {
static boolean doThrow = false;
@@ -266,14 +266,14 @@
* we don't do generate a clinit check.
*/
- // CHECK-START: void Main.noClinitBecauseOfInvokeStatic() liveness (before)
- // CHECK-DAG: <<IntConstant:i\d+>> IntConstant 0
- // CHECK-DAG: <<LoadClass:l\d+>> LoadClass gen_clinit_check:false
- // CHECK-DAG: InvokeStaticOrDirect
- // CHECK-DAG: StaticFieldSet [<<LoadClass>>,<<IntConstant>>]
+ /// CHECK-START: void Main.noClinitBecauseOfInvokeStatic() liveness (before)
+ /// CHECK-DAG: <<IntConstant:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<LoadClass:l\d+>> LoadClass gen_clinit_check:false
+ /// CHECK-DAG: InvokeStaticOrDirect
+ /// CHECK-DAG: StaticFieldSet [<<LoadClass>>,<<IntConstant>>]
- // CHECK-START: void Main.noClinitBecauseOfInvokeStatic() liveness (before)
- // CHECK-NOT: ClinitCheck
+ /// CHECK-START: void Main.noClinitBecauseOfInvokeStatic() liveness (before)
+ /// CHECK-NOT: ClinitCheck
static void noClinitBecauseOfInvokeStatic() {
ClassWithClinit2.staticMethod();
@@ -285,14 +285,14 @@
* will generate a clinit check.
*/
- // CHECK-START: void Main.clinitBecauseOfFieldAccess() liveness (before)
- // CHECK-DAG: <<IntConstant:i\d+>> IntConstant 0
- // CHECK-DAG: <<LoadClass:l\d+>> LoadClass gen_clinit_check:true
- // CHECK-DAG: StaticFieldSet [<<LoadClass>>,<<IntConstant>>]
- // CHECK-DAG: InvokeStaticOrDirect
+ /// CHECK-START: void Main.clinitBecauseOfFieldAccess() liveness (before)
+ /// CHECK-DAG: <<IntConstant:i\d+>> IntConstant 0
+ /// CHECK-DAG: <<LoadClass:l\d+>> LoadClass gen_clinit_check:true
+ /// CHECK-DAG: StaticFieldSet [<<LoadClass>>,<<IntConstant>>]
+ /// CHECK-DAG: InvokeStaticOrDirect
- // CHECK-START: void Main.clinitBecauseOfFieldAccess() liveness (before)
- // CHECK-NOT: ClinitCheck
+ /// CHECK-START: void Main.clinitBecauseOfFieldAccess() liveness (before)
+ /// CHECK-NOT: ClinitCheck
static void clinitBecauseOfFieldAccess() {
ClassWithClinit2.doThrow = false;
ClassWithClinit2.staticMethod();
diff --git a/test/478-checker-inliner-nested-loop/src/Main.java b/test/478-checker-inliner-nested-loop/src/Main.java
index df583d9..aa02349 100644
--- a/test/478-checker-inliner-nested-loop/src/Main.java
+++ b/test/478-checker-inliner-nested-loop/src/Main.java
@@ -33,12 +33,12 @@
return result;
}
- // CHECK-START: int Main.NestedLoop(int, int) inliner (before)
- // CHECK-NOT: Mul
+ /// CHECK-START: int Main.NestedLoop(int, int) inliner (before)
+ /// CHECK-NOT: Mul
- // CHECK-START: int Main.NestedLoop(int, int) inliner (after)
- // CHECK: Mul
- // CHECK-NOT: Mul
+ /// CHECK-START: int Main.NestedLoop(int, int) inliner (after)
+ /// CHECK: Mul
+ /// CHECK-NOT: Mul
public static int NestedLoop(int max_x, int max_y) {
int total = 0;
diff --git a/test/480-checker-dead-blocks/src/Main.java b/test/480-checker-dead-blocks/src/Main.java
index b76755e..4cc1634 100644
--- a/test/480-checker-dead-blocks/src/Main.java
+++ b/test/480-checker-dead-blocks/src/Main.java
@@ -30,25 +30,25 @@
return false;
}
- // CHECK-START: int Main.testTrueBranch(int, int) dead_code_elimination_final (before)
- // CHECK-DAG: <<ArgX:i\d+>> ParameterValue
- // CHECK-DAG: <<ArgY:i\d+>> ParameterValue
- // CHECK-DAG: If
- // CHECK-DAG: <<Add:i\d+>> Add [<<ArgX>>,<<ArgY>>]
- // CHECK-DAG: <<Sub:i\d+>> Sub [<<ArgX>>,<<ArgY>>]
- // CHECK-DAG: <<Phi:i\d+>> Phi [<<Add>>,<<Sub>>]
- // CHECK-DAG: Return [<<Phi>>]
+ /// CHECK-START: int Main.testTrueBranch(int, int) dead_code_elimination_final (before)
+ /// CHECK-DAG: <<ArgX:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ArgY:i\d+>> ParameterValue
+ /// CHECK-DAG: If
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<ArgX>>,<<ArgY>>]
+ /// CHECK-DAG: <<Sub:i\d+>> Sub [<<ArgX>>,<<ArgY>>]
+ /// CHECK-DAG: <<Phi:i\d+>> Phi [<<Add>>,<<Sub>>]
+ /// CHECK-DAG: Return [<<Phi>>]
- // CHECK-START: int Main.testTrueBranch(int, int) dead_code_elimination_final (after)
- // CHECK-DAG: <<ArgX:i\d+>> ParameterValue
- // CHECK-DAG: <<ArgY:i\d+>> ParameterValue
- // CHECK-DAG: <<Add:i\d+>> Add [<<ArgX>>,<<ArgY>>]
- // CHECK-DAG: Return [<<Add>>]
+ /// CHECK-START: int Main.testTrueBranch(int, int) dead_code_elimination_final (after)
+ /// CHECK-DAG: <<ArgX:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ArgY:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<ArgX>>,<<ArgY>>]
+ /// CHECK-DAG: Return [<<Add>>]
- // CHECK-START: int Main.testTrueBranch(int, int) dead_code_elimination_final (after)
- // CHECK-NOT: If
- // CHECK-NOT: Sub
- // CHECK-NOT: Phi
+ /// CHECK-START: int Main.testTrueBranch(int, int) dead_code_elimination_final (after)
+ /// CHECK-NOT: If
+ /// CHECK-NOT: Sub
+ /// CHECK-NOT: Phi
public static int testTrueBranch(int x, int y) {
int z;
@@ -60,25 +60,25 @@
return z;
}
- // CHECK-START: int Main.testFalseBranch(int, int) dead_code_elimination_final (before)
- // CHECK-DAG: <<ArgX:i\d+>> ParameterValue
- // CHECK-DAG: <<ArgY:i\d+>> ParameterValue
- // CHECK-DAG: If
- // CHECK-DAG: <<Add:i\d+>> Add [<<ArgX>>,<<ArgY>>]
- // CHECK-DAG: <<Sub:i\d+>> Sub [<<ArgX>>,<<ArgY>>]
- // CHECK-DAG: <<Phi:i\d+>> Phi [<<Add>>,<<Sub>>]
- // CHECK-DAG: Return [<<Phi>>]
+ /// CHECK-START: int Main.testFalseBranch(int, int) dead_code_elimination_final (before)
+ /// CHECK-DAG: <<ArgX:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ArgY:i\d+>> ParameterValue
+ /// CHECK-DAG: If
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<ArgX>>,<<ArgY>>]
+ /// CHECK-DAG: <<Sub:i\d+>> Sub [<<ArgX>>,<<ArgY>>]
+ /// CHECK-DAG: <<Phi:i\d+>> Phi [<<Add>>,<<Sub>>]
+ /// CHECK-DAG: Return [<<Phi>>]
- // CHECK-START: int Main.testFalseBranch(int, int) dead_code_elimination_final (after)
- // CHECK-DAG: <<ArgX:i\d+>> ParameterValue
- // CHECK-DAG: <<ArgY:i\d+>> ParameterValue
- // CHECK-DAG: <<Sub:i\d+>> Sub [<<ArgX>>,<<ArgY>>]
- // CHECK-DAG: Return [<<Sub>>]
+ /// CHECK-START: int Main.testFalseBranch(int, int) dead_code_elimination_final (after)
+ /// CHECK-DAG: <<ArgX:i\d+>> ParameterValue
+ /// CHECK-DAG: <<ArgY:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Sub:i\d+>> Sub [<<ArgX>>,<<ArgY>>]
+ /// CHECK-DAG: Return [<<Sub>>]
- // CHECK-START: int Main.testFalseBranch(int, int) dead_code_elimination_final (after)
- // CHECK-NOT: If
- // CHECK-NOT: Add
- // CHECK-NOT: Phi
+ /// CHECK-START: int Main.testFalseBranch(int, int) dead_code_elimination_final (after)
+ /// CHECK-NOT: If
+ /// CHECK-NOT: Add
+ /// CHECK-NOT: Phi
public static int testFalseBranch(int x, int y) {
int z;
@@ -90,11 +90,11 @@
return z;
}
- // CHECK-START: int Main.testRemoveLoop(int) dead_code_elimination_final (before)
- // CHECK: Mul
+ /// CHECK-START: int Main.testRemoveLoop(int) dead_code_elimination_final (before)
+ /// CHECK: Mul
- // CHECK-START: int Main.testRemoveLoop(int) dead_code_elimination_final (after)
- // CHECK-NOT: Mul
+ /// CHECK-START: int Main.testRemoveLoop(int) dead_code_elimination_final (after)
+ /// CHECK-NOT: Mul
public static int testRemoveLoop(int x) {
if (inlineFalse()) {
@@ -105,13 +105,13 @@
return x;
}
- // CHECK-START: int Main.testInfiniteLoop(int) dead_code_elimination_final (before)
- // CHECK-DAG: Return
- // CHECK-DAG: Exit
+ /// CHECK-START: int Main.testInfiniteLoop(int) dead_code_elimination_final (before)
+ /// CHECK-DAG: Return
+ /// CHECK-DAG: Exit
- // CHECK-START: int Main.testInfiniteLoop(int) dead_code_elimination_final (after)
- // CHECK-NOT: Return
- // CHECK-NOT: Exit
+ /// CHECK-START: int Main.testInfiniteLoop(int) dead_code_elimination_final (after)
+ /// CHECK-NOT: Return
+ /// CHECK-NOT: Exit
public static int testInfiniteLoop(int x) {
while (inlineTrue()) {
@@ -120,17 +120,17 @@
return x;
}
- // CHECK-START: int Main.testDeadLoop(int) dead_code_elimination_final (before)
- // CHECK-DAG: If
- // CHECK-DAG: Add
+ /// CHECK-START: int Main.testDeadLoop(int) dead_code_elimination_final (before)
+ /// CHECK-DAG: If
+ /// CHECK-DAG: Add
- // CHECK-START: int Main.testDeadLoop(int) dead_code_elimination_final (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: int Main.testDeadLoop(int) dead_code_elimination_final (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: int Main.testDeadLoop(int) dead_code_elimination_final (after)
- // CHECK-NOT: If
- // CHECK-NOT: Add
+ /// CHECK-START: int Main.testDeadLoop(int) dead_code_elimination_final (after)
+ /// CHECK-NOT: If
+ /// CHECK-NOT: Add
public static int testDeadLoop(int x) {
while (inlineFalse()) {
@@ -139,18 +139,18 @@
return x;
}
- // CHECK-START: int Main.testUpdateLoopInformation(int) dead_code_elimination_final (before)
- // CHECK-DAG: If
- // CHECK-DAG: If
- // CHECK-DAG: Add
+ /// CHECK-START: int Main.testUpdateLoopInformation(int) dead_code_elimination_final (before)
+ /// CHECK-DAG: If
+ /// CHECK-DAG: If
+ /// CHECK-DAG: Add
- // CHECK-START: int Main.testUpdateLoopInformation(int) dead_code_elimination_final (after)
- // CHECK-DAG: <<Arg:i\d+>> ParameterValue
- // CHECK-DAG: Return [<<Arg>>]
+ /// CHECK-START: int Main.testUpdateLoopInformation(int) dead_code_elimination_final (after)
+ /// CHECK-DAG: <<Arg:i\d+>> ParameterValue
+ /// CHECK-DAG: Return [<<Arg>>]
- // CHECK-START: int Main.testUpdateLoopInformation(int) dead_code_elimination_final (after)
- // CHECK-NOT: If
- // CHECK-NOT: Add
+ /// CHECK-START: int Main.testUpdateLoopInformation(int) dead_code_elimination_final (after)
+ /// CHECK-NOT: If
+ /// CHECK-NOT: Add
public static int testUpdateLoopInformation(int x) {
// Use of Or in the condition generates a dead loop where not all of its
@@ -161,16 +161,16 @@
return x;
}
- // CHECK-START: int Main.testRemoveSuspendCheck(int, int) dead_code_elimination_final (before)
- // CHECK: SuspendCheck
- // CHECK: SuspendCheck
- // CHECK: SuspendCheck
- // CHECK-NOT: SuspendCheck
+ /// CHECK-START: int Main.testRemoveSuspendCheck(int, int) dead_code_elimination_final (before)
+ /// CHECK: SuspendCheck
+ /// CHECK: SuspendCheck
+ /// CHECK: SuspendCheck
+ /// CHECK-NOT: SuspendCheck
- // CHECK-START: int Main.testRemoveSuspendCheck(int, int) dead_code_elimination_final (after)
- // CHECK: SuspendCheck
- // CHECK: SuspendCheck
- // CHECK-NOT: SuspendCheck
+ /// CHECK-START: int Main.testRemoveSuspendCheck(int, int) dead_code_elimination_final (after)
+ /// CHECK: SuspendCheck
+ /// CHECK: SuspendCheck
+ /// CHECK-NOT: SuspendCheck
public static int testRemoveSuspendCheck(int x, int y) {
// Inner loop will leave behind the header with its SuspendCheck. DCE must
diff --git a/test/482-checker-loop-back-edge-use/src/Main.java b/test/482-checker-loop-back-edge-use/src/Main.java
index f579692..5754723 100644
--- a/test/482-checker-loop-back-edge-use/src/Main.java
+++ b/test/482-checker-loop-back-edge-use/src/Main.java
@@ -17,17 +17,17 @@
public class Main {
- // CHECK-START: void Main.loop1(boolean) liveness (after)
- // CHECK: ParameterValue liveness:2 ranges:{[2,22)} uses:[17,22]
- // CHECK: Goto liveness:20
+ /// CHECK-START: void Main.loop1(boolean) liveness (after)
+ /// CHECK: ParameterValue liveness:2 ranges:{[2,22)} uses:[17,22]
+ /// CHECK: Goto liveness:20
public static void loop1(boolean incoming) {
while (incoming) {}
}
- // CHECK-START: void Main.loop2(boolean) liveness (after)
- // CHECK: ParameterValue liveness:4 ranges:{[4,44)} uses:[35,40,44]
- // CHECK: Goto liveness:38
- // CHECK: Goto liveness:42
+ /// CHECK-START: void Main.loop2(boolean) liveness (after)
+ /// CHECK: ParameterValue liveness:4 ranges:{[4,44)} uses:[35,40,44]
+ /// CHECK: Goto liveness:38
+ /// CHECK: Goto liveness:42
public static void loop2(boolean incoming) {
while (true) {
System.out.println("foo");
@@ -35,12 +35,12 @@
}
}
- // CHECK-START: void Main.loop3(boolean) liveness (after)
- // CHECK: ParameterValue liveness:4 ranges:{[4,62)} uses:[58,62]
- // CHECK: Goto liveness:60
+ /// CHECK-START: void Main.loop3(boolean) liveness (after)
+ /// CHECK: ParameterValue liveness:4 ranges:{[4,62)} uses:[58,62]
+ /// CHECK: Goto liveness:60
- // CHECK-START: void Main.loop3(boolean) liveness (after)
- // CHECK-NOT: Goto liveness:56
+ /// CHECK-START: void Main.loop3(boolean) liveness (after)
+ /// CHECK-NOT: Goto liveness:56
public static void loop3(boolean incoming) {
// 'incoming' only needs a use at the outer loop's back edge.
while (System.currentTimeMillis() != 42) {
@@ -49,11 +49,11 @@
}
}
- // CHECK-START: void Main.loop4(boolean) liveness (after)
- // CHECK: ParameterValue liveness:4 ranges:{[4,24)} uses:[24]
+ /// CHECK-START: void Main.loop4(boolean) liveness (after)
+ /// CHECK: ParameterValue liveness:4 ranges:{[4,24)} uses:[24]
- // CHECK-START: void Main.loop4(boolean) liveness (after)
- // CHECK-NOT: Goto liveness:22
+ /// CHECK-START: void Main.loop4(boolean) liveness (after)
+ /// CHECK-NOT: Goto liveness:22
public static void loop4(boolean incoming) {
// 'incoming' has no loop use, so should not have back edge uses.
System.out.println(incoming);
@@ -62,10 +62,10 @@
}
}
- // CHECK-START: void Main.loop5(boolean) liveness (after)
- // CHECK: ParameterValue liveness:4 ranges:{[4,52)} uses:[35,44,48,52]
- // CHECK: Goto liveness:46
- // CHECK: Goto liveness:50
+ /// CHECK-START: void Main.loop5(boolean) liveness (after)
+ /// CHECK: ParameterValue liveness:4 ranges:{[4,52)} uses:[35,44,48,52]
+ /// CHECK: Goto liveness:46
+ /// CHECK: Goto liveness:50
public static void loop5(boolean incoming) {
// 'incoming' must have a use at both back edges.
while (Runtime.getRuntime() != null) {
@@ -75,12 +75,12 @@
}
}
- // CHECK-START: void Main.loop6(boolean) liveness (after)
- // CHECK: ParameterValue liveness:4 ranges:{[4,48)} uses:[26,48]
- // CHECK: Goto liveness:46
+ /// CHECK-START: void Main.loop6(boolean) liveness (after)
+ /// CHECK: ParameterValue liveness:4 ranges:{[4,48)} uses:[26,48]
+ /// CHECK: Goto liveness:46
- // CHECK-START: void Main.loop6(boolean) liveness (after)
- // CHECK-NOT: Goto liveness:24
+ /// CHECK-START: void Main.loop6(boolean) liveness (after)
+ /// CHECK-NOT: Goto liveness:24
public static void loop6(boolean incoming) {
// 'incoming' must have a use only at the first loop's back edge.
while (true) {
@@ -89,10 +89,10 @@
}
}
- // CHECK-START: void Main.loop7(boolean) liveness (after)
- // CHECK: ParameterValue liveness:4 ranges:{[4,52)} uses:[34,43,48,52]
- // CHECK: Goto liveness:46
- // CHECK: Goto liveness:50
+ /// CHECK-START: void Main.loop7(boolean) liveness (after)
+ /// CHECK: ParameterValue liveness:4 ranges:{[4,52)} uses:[34,43,48,52]
+ /// CHECK: Goto liveness:46
+ /// CHECK: Goto liveness:50
public static void loop7(boolean incoming) {
// 'incoming' must have a use at both back edges.
while (Runtime.getRuntime() != null) {
@@ -101,10 +101,10 @@
}
}
- // CHECK-START: void Main.loop8() liveness (after)
- // CHECK: StaticFieldGet liveness:14 ranges:{[14,46)} uses:[37,42,46]
- // CHECK: Goto liveness:40
- // CHECK: Goto liveness:44
+ /// CHECK-START: void Main.loop8() liveness (after)
+ /// CHECK: StaticFieldGet liveness:14 ranges:{[14,46)} uses:[37,42,46]
+ /// CHECK: Goto liveness:40
+ /// CHECK: Goto liveness:44
public static void loop8() {
// 'incoming' must have a use at both back edges.
boolean incoming = field;
@@ -113,9 +113,9 @@
}
}
- // CHECK-START: void Main.loop9() liveness (after)
- // CHECK: StaticFieldGet liveness:24 ranges:{[24,38)} uses:[33,38]
- // CHECK: Goto liveness:40
+ /// CHECK-START: void Main.loop9() liveness (after)
+ /// CHECK: StaticFieldGet liveness:24 ranges:{[24,38)} uses:[33,38]
+ /// CHECK: Goto liveness:40
public static void loop9() {
while (Runtime.getRuntime() != null) {
// 'incoming' must only have a use in the inner loop.
diff --git a/test/484-checker-register-hints/src/Main.java b/test/484-checker-register-hints/src/Main.java
index 33952d9..3715ca2 100644
--- a/test/484-checker-register-hints/src/Main.java
+++ b/test/484-checker-register-hints/src/Main.java
@@ -16,21 +16,21 @@
public class Main {
- // CHECK-START: void Main.test1(boolean, int, int, int, int, int) register (after)
- // CHECK: name "B0"
- // CHECK-NOT: ParallelMove
- // CHECK: name "B1"
- // CHECK-NOT: end_block
- // CHECK: If
- // CHECK-NOT: ParallelMove
- // CHECK: name "B3"
- // CHECK-NOT: end_block
- // CHECK: ArraySet
+ /// CHECK-START: void Main.test1(boolean, int, int, int, int, int) register (after)
+ /// CHECK: name "B0"
+ /// CHECK-NOT: ParallelMove
+ /// CHECK: name "B1"
+ /// CHECK-NOT: end_block
+ /// CHECK: If
+ /// CHECK-NOT: ParallelMove
+ /// CHECK: name "B3"
+ /// CHECK-NOT: end_block
+ /// CHECK: ArraySet
// We could check here that there is a parallel move, but it's only valid
// for some architectures (for example x86), as other architectures may
// not do move at all.
- // CHECK: end_block
- // CHECK-NOT: ParallelMove
+ /// CHECK: end_block
+ /// CHECK-NOT: ParallelMove
public static void test1(boolean z, int a, int b, int c, int d, int m) {
int e = live1;
@@ -51,21 +51,21 @@
live1 = e + f + g;
}
- // CHECK-START: void Main.test2(boolean, int, int, int, int, int) register (after)
- // CHECK: name "B0"
- // CHECK-NOT: ParallelMove
- // CHECK: name "B1"
- // CHECK-NOT: end_block
- // CHECK: If
- // CHECK-NOT: ParallelMove
- // CHECK: name "B3"
- // CHECK-NOT: end_block
- // CHECK: ArraySet
+ /// CHECK-START: void Main.test2(boolean, int, int, int, int, int) register (after)
+ /// CHECK: name "B0"
+ /// CHECK-NOT: ParallelMove
+ /// CHECK: name "B1"
+ /// CHECK-NOT: end_block
+ /// CHECK: If
+ /// CHECK-NOT: ParallelMove
+ /// CHECK: name "B3"
+ /// CHECK-NOT: end_block
+ /// CHECK: ArraySet
// We could check here that there is a parallel move, but it's only valid
// for some architectures (for example x86), as other architectures may
// not do move at all.
- // CHECK: end_block
- // CHECK-NOT: ParallelMove
+ /// CHECK: end_block
+ /// CHECK-NOT: ParallelMove
public static void test2(boolean z, int a, int b, int c, int d, int m) {
int e = live1;
@@ -85,21 +85,21 @@
live1 = e + f + g;
}
- // CHECK-START: void Main.test3(boolean, int, int, int, int, int) register (after)
- // CHECK: name "B0"
- // CHECK-NOT: ParallelMove
- // CHECK: name "B1"
- // CHECK-NOT: end_block
- // CHECK: If
- // CHECK-NOT: ParallelMove
- // CHECK: name "B6"
- // CHECK-NOT: end_block
- // CHECK: ArraySet
+ /// CHECK-START: void Main.test3(boolean, int, int, int, int, int) register (after)
+ /// CHECK: name "B0"
+ /// CHECK-NOT: ParallelMove
+ /// CHECK: name "B1"
+ /// CHECK-NOT: end_block
+ /// CHECK: If
+ /// CHECK-NOT: ParallelMove
+ /// CHECK: name "B6"
+ /// CHECK-NOT: end_block
+ /// CHECK: ArraySet
// We could check here that there is a parallel move, but it's only valid
// for some architectures (for example x86), as other architectures may
// not do move at all.
- // CHECK: end_block
- // CHECK-NOT: ParallelMove
+ /// CHECK: end_block
+ /// CHECK-NOT: ParallelMove
public static void test3(boolean z, int a, int b, int c, int d, int m) {
// Same version as test2, but with branches reversed, to ensure
diff --git a/test/485-checker-dce-loop-update/smali/TestCase.smali b/test/485-checker-dce-loop-update/smali/TestCase.smali
index 487a5df..da27bf6 100644
--- a/test/485-checker-dce-loop-update/smali/TestCase.smali
+++ b/test/485-checker-dce-loop-update/smali/TestCase.smali
@@ -23,27 +23,27 @@
.end method
-# CHECK-START: int TestCase.testSingleExit(int, boolean) dead_code_elimination_final (before)
-# CHECK-DAG: <<ArgX:i\d+>> ParameterValue
-# CHECK-DAG: <<ArgY:z\d+>> ParameterValue
-# CHECK-DAG: <<Cst1:i\d+>> IntConstant 1
-# CHECK-DAG: <<Cst5:i\d+>> IntConstant 5
-# CHECK-DAG: <<Cst7:i\d+>> IntConstant 7
-# CHECK-DAG: <<PhiX:i\d+>> Phi [<<ArgX>>,<<Add5:i\d+>>,<<Add7:i\d+>>] loop:<<HeaderY:B\d+>>
-# CHECK-DAG: If [<<ArgY>>] loop:<<HeaderY>>
-# CHECK-DAG: If [<<Cst1>>] loop:<<HeaderY>>
-# CHECK-DAG: <<Add5>> Add [<<PhiX>>,<<Cst5>>] loop:<<HeaderY>>
-# CHECK-DAG: <<Add7>> Add [<<PhiX>>,<<Cst7>>] loop:<<HeaderY>>
-# CHECK-DAG: Return [<<PhiX>>] loop:none
+## CHECK-START: int TestCase.testSingleExit(int, boolean) dead_code_elimination_final (before)
+## CHECK-DAG: <<ArgX:i\d+>> ParameterValue
+## CHECK-DAG: <<ArgY:z\d+>> ParameterValue
+## CHECK-DAG: <<Cst1:i\d+>> IntConstant 1
+## CHECK-DAG: <<Cst5:i\d+>> IntConstant 5
+## CHECK-DAG: <<Cst7:i\d+>> IntConstant 7
+## CHECK-DAG: <<PhiX:i\d+>> Phi [<<ArgX>>,<<Add5:i\d+>>,<<Add7:i\d+>>] loop:<<HeaderY:B\d+>>
+## CHECK-DAG: If [<<ArgY>>] loop:<<HeaderY>>
+## CHECK-DAG: If [<<Cst1>>] loop:<<HeaderY>>
+## CHECK-DAG: <<Add5>> Add [<<PhiX>>,<<Cst5>>] loop:<<HeaderY>>
+## CHECK-DAG: <<Add7>> Add [<<PhiX>>,<<Cst7>>] loop:<<HeaderY>>
+## CHECK-DAG: Return [<<PhiX>>] loop:none
-# CHECK-START: int TestCase.testSingleExit(int, boolean) dead_code_elimination_final (after)
-# CHECK-DAG: <<ArgX:i\d+>> ParameterValue
-# CHECK-DAG: <<ArgY:z\d+>> ParameterValue
-# CHECK-DAG: <<Cst7:i\d+>> IntConstant 7
-# CHECK-DAG: <<PhiX:i\d+>> Phi [<<ArgX>>,<<AddX:i\d+>>] loop:<<HeaderY:B\d+>>
-# CHECK-DAG: If [<<ArgY>>] loop:<<HeaderY>>
-# CHECK-DAG: <<AddX>> Add [<<PhiX>>,<<Cst7>>] loop:<<HeaderY>>
-# CHECK-DAG: Return [<<PhiX>>] loop:none
+## CHECK-START: int TestCase.testSingleExit(int, boolean) dead_code_elimination_final (after)
+## CHECK-DAG: <<ArgX:i\d+>> ParameterValue
+## CHECK-DAG: <<ArgY:z\d+>> ParameterValue
+## CHECK-DAG: <<Cst7:i\d+>> IntConstant 7
+## CHECK-DAG: <<PhiX:i\d+>> Phi [<<ArgX>>,<<AddX:i\d+>>] loop:<<HeaderY:B\d+>>
+## CHECK-DAG: If [<<ArgY>>] loop:<<HeaderY>>
+## CHECK-DAG: <<AddX>> Add [<<PhiX>>,<<Cst7>>] loop:<<HeaderY>>
+## CHECK-DAG: Return [<<PhiX>>] loop:none
.method public static testSingleExit(IZ)I
.registers 3
@@ -73,31 +73,31 @@
.end method
-# CHECK-START: int TestCase.testMultipleExits(int, boolean, boolean) dead_code_elimination_final (before)
-# CHECK-DAG: <<ArgX:i\d+>> ParameterValue
-# CHECK-DAG: <<ArgY:z\d+>> ParameterValue
-# CHECK-DAG: <<ArgZ:z\d+>> ParameterValue
-# CHECK-DAG: <<Cst1:i\d+>> IntConstant 1
-# CHECK-DAG: <<Cst5:i\d+>> IntConstant 5
-# CHECK-DAG: <<Cst7:i\d+>> IntConstant 7
-# CHECK-DAG: <<PhiX:i\d+>> Phi [<<ArgX>>,<<Add5:i\d+>>,<<Add7:i\d+>>] loop:<<HeaderY:B\d+>>
-# CHECK-DAG: If [<<ArgY>>] loop:<<HeaderY>>
-# CHECK-DAG: If [<<ArgZ>>] loop:<<HeaderY>>
-# CHECK-DAG: If [<<Cst1>>] loop:<<HeaderY>>
-# CHECK-DAG: <<Add5>> Add [<<PhiX>>,<<Cst5>>] loop:<<HeaderY>>
-# CHECK-DAG: <<Add7>> Add [<<PhiX>>,<<Cst7>>] loop:<<HeaderY>>
-# CHECK-DAG: Return [<<PhiX>>] loop:none
+## CHECK-START: int TestCase.testMultipleExits(int, boolean, boolean) dead_code_elimination_final (before)
+## CHECK-DAG: <<ArgX:i\d+>> ParameterValue
+## CHECK-DAG: <<ArgY:z\d+>> ParameterValue
+## CHECK-DAG: <<ArgZ:z\d+>> ParameterValue
+## CHECK-DAG: <<Cst1:i\d+>> IntConstant 1
+## CHECK-DAG: <<Cst5:i\d+>> IntConstant 5
+## CHECK-DAG: <<Cst7:i\d+>> IntConstant 7
+## CHECK-DAG: <<PhiX:i\d+>> Phi [<<ArgX>>,<<Add5:i\d+>>,<<Add7:i\d+>>] loop:<<HeaderY:B\d+>>
+## CHECK-DAG: If [<<ArgY>>] loop:<<HeaderY>>
+## CHECK-DAG: If [<<ArgZ>>] loop:<<HeaderY>>
+## CHECK-DAG: If [<<Cst1>>] loop:<<HeaderY>>
+## CHECK-DAG: <<Add5>> Add [<<PhiX>>,<<Cst5>>] loop:<<HeaderY>>
+## CHECK-DAG: <<Add7>> Add [<<PhiX>>,<<Cst7>>] loop:<<HeaderY>>
+## CHECK-DAG: Return [<<PhiX>>] loop:none
-# CHECK-START: int TestCase.testMultipleExits(int, boolean, boolean) dead_code_elimination_final (after)
-# CHECK-DAG: <<ArgX:i\d+>> ParameterValue
-# CHECK-DAG: <<ArgY:z\d+>> ParameterValue
-# CHECK-DAG: <<ArgZ:z\d+>> ParameterValue
-# CHECK-DAG: <<Cst7:i\d+>> IntConstant 7
-# CHECK-DAG: <<PhiX:i\d+>> Phi [<<ArgX>>,<<Add7:i\d+>>] loop:<<HeaderY:B\d+>>
-# CHECK-DAG: If [<<ArgY>>] loop:<<HeaderY>>
-# CHECK-DAG: <<Add7>> Add [<<PhiX>>,<<Cst7>>] loop:<<HeaderY>>
-# CHECK-DAG: If [<<ArgZ>>] loop:none
-# CHECK-DAG: Return [<<PhiX>>] loop:none
+## CHECK-START: int TestCase.testMultipleExits(int, boolean, boolean) dead_code_elimination_final (after)
+## CHECK-DAG: <<ArgX:i\d+>> ParameterValue
+## CHECK-DAG: <<ArgY:z\d+>> ParameterValue
+## CHECK-DAG: <<ArgZ:z\d+>> ParameterValue
+## CHECK-DAG: <<Cst7:i\d+>> IntConstant 7
+## CHECK-DAG: <<PhiX:i\d+>> Phi [<<ArgX>>,<<Add7:i\d+>>] loop:<<HeaderY:B\d+>>
+## CHECK-DAG: If [<<ArgY>>] loop:<<HeaderY>>
+## CHECK-DAG: <<Add7>> Add [<<PhiX>>,<<Cst7>>] loop:<<HeaderY>>
+## CHECK-DAG: If [<<ArgZ>>] loop:none
+## CHECK-DAG: Return [<<PhiX>>] loop:none
.method public static testMultipleExits(IZZ)I
.registers 4
@@ -129,37 +129,37 @@
.end method
-# CHECK-START: int TestCase.testExitPredecessors(int, boolean, boolean) dead_code_elimination_final (before)
-# CHECK-DAG: <<ArgX:i\d+>> ParameterValue
-# CHECK-DAG: <<ArgY:z\d+>> ParameterValue
-# CHECK-DAG: <<ArgZ:z\d+>> ParameterValue
-# CHECK-DAG: <<Cst1:i\d+>> IntConstant 1
-# CHECK-DAG: <<Cst5:i\d+>> IntConstant 5
-# CHECK-DAG: <<Cst7:i\d+>> IntConstant 7
-# CHECK-DAG: <<Cst9:i\d+>> IntConstant 9
-# CHECK-DAG: <<PhiX1:i\d+>> Phi [<<ArgX>>,<<Add5:i\d+>>,<<Add7:i\d+>>] loop:<<HeaderY:B\d+>>
-# CHECK-DAG: If [<<ArgY>>] loop:<<HeaderY>>
-# CHECK-DAG: If [<<ArgZ>>] loop:<<HeaderY>>
-# CHECK-DAG: <<Mul9:i\d+>> Mul [<<PhiX1>>,<<Cst9>>] loop:<<HeaderY>>
-# CHECK-DAG: <<PhiX2:i\d+>> Phi [<<Mul9>>,<<PhiX1>>] loop:<<HeaderY>>
-# CHECK-DAG: If [<<Cst1>>] loop:<<HeaderY>>
-# CHECK-DAG: <<Add5>> Add [<<PhiX2>>,<<Cst5>>] loop:<<HeaderY>>
-# CHECK-DAG: <<Add7>> Add [<<PhiX1>>,<<Cst7>>] loop:<<HeaderY>>
-# CHECK-DAG: Return [<<PhiX2>>] loop:none
+## CHECK-START: int TestCase.testExitPredecessors(int, boolean, boolean) dead_code_elimination_final (before)
+## CHECK-DAG: <<ArgX:i\d+>> ParameterValue
+## CHECK-DAG: <<ArgY:z\d+>> ParameterValue
+## CHECK-DAG: <<ArgZ:z\d+>> ParameterValue
+## CHECK-DAG: <<Cst1:i\d+>> IntConstant 1
+## CHECK-DAG: <<Cst5:i\d+>> IntConstant 5
+## CHECK-DAG: <<Cst7:i\d+>> IntConstant 7
+## CHECK-DAG: <<Cst9:i\d+>> IntConstant 9
+## CHECK-DAG: <<PhiX1:i\d+>> Phi [<<ArgX>>,<<Add5:i\d+>>,<<Add7:i\d+>>] loop:<<HeaderY:B\d+>>
+## CHECK-DAG: If [<<ArgY>>] loop:<<HeaderY>>
+## CHECK-DAG: If [<<ArgZ>>] loop:<<HeaderY>>
+## CHECK-DAG: <<Mul9:i\d+>> Mul [<<PhiX1>>,<<Cst9>>] loop:<<HeaderY>>
+## CHECK-DAG: <<PhiX2:i\d+>> Phi [<<Mul9>>,<<PhiX1>>] loop:<<HeaderY>>
+## CHECK-DAG: If [<<Cst1>>] loop:<<HeaderY>>
+## CHECK-DAG: <<Add5>> Add [<<PhiX2>>,<<Cst5>>] loop:<<HeaderY>>
+## CHECK-DAG: <<Add7>> Add [<<PhiX1>>,<<Cst7>>] loop:<<HeaderY>>
+## CHECK-DAG: Return [<<PhiX2>>] loop:none
-# CHECK-START: int TestCase.testExitPredecessors(int, boolean, boolean) dead_code_elimination_final (after)
-# CHECK-DAG: <<ArgX:i\d+>> ParameterValue
-# CHECK-DAG: <<ArgY:z\d+>> ParameterValue
-# CHECK-DAG: <<ArgZ:z\d+>> ParameterValue
-# CHECK-DAG: <<Cst7:i\d+>> IntConstant 7
-# CHECK-DAG: <<Cst9:i\d+>> IntConstant 9
-# CHECK-DAG: <<PhiX1:i\d+>> Phi [<<ArgX>>,<<Add7:i\d+>>] loop:<<HeaderY:B\d+>>
-# CHECK-DAG: If [<<ArgY>>] loop:<<HeaderY>>
-# CHECK-DAG: <<Add7>> Add [<<PhiX1>>,<<Cst7>>] loop:<<HeaderY>>
-# CHECK-DAG: If [<<ArgZ>>] loop:none
-# CHECK-DAG: <<Mul9:i\d+>> Mul [<<PhiX1>>,<<Cst9>>] loop:none
-# CHECK-DAG: <<PhiX2:i\d+>> Phi [<<Mul9>>,<<PhiX1>>] loop:none
-# CHECK-DAG: Return [<<PhiX2>>] loop:none
+## CHECK-START: int TestCase.testExitPredecessors(int, boolean, boolean) dead_code_elimination_final (after)
+## CHECK-DAG: <<ArgX:i\d+>> ParameterValue
+## CHECK-DAG: <<ArgY:z\d+>> ParameterValue
+## CHECK-DAG: <<ArgZ:z\d+>> ParameterValue
+## CHECK-DAG: <<Cst7:i\d+>> IntConstant 7
+## CHECK-DAG: <<Cst9:i\d+>> IntConstant 9
+## CHECK-DAG: <<PhiX1:i\d+>> Phi [<<ArgX>>,<<Add7:i\d+>>] loop:<<HeaderY:B\d+>>
+## CHECK-DAG: If [<<ArgY>>] loop:<<HeaderY>>
+## CHECK-DAG: <<Add7>> Add [<<PhiX1>>,<<Cst7>>] loop:<<HeaderY>>
+## CHECK-DAG: If [<<ArgZ>>] loop:none
+## CHECK-DAG: <<Mul9:i\d+>> Mul [<<PhiX1>>,<<Cst9>>] loop:none
+## CHECK-DAG: <<PhiX2:i\d+>> Phi [<<Mul9>>,<<PhiX1>>] loop:none
+## CHECK-DAG: Return [<<PhiX2>>] loop:none
.method public static testExitPredecessors(IZZ)I
.registers 4
@@ -196,48 +196,48 @@
.end method
-# CHECK-START: int TestCase.testInnerLoop(int, boolean, boolean) dead_code_elimination_final (before)
-# CHECK-DAG: <<ArgX:i\d+>> ParameterValue
-# CHECK-DAG: <<ArgY:z\d+>> ParameterValue
-# CHECK-DAG: <<ArgZ:z\d+>> ParameterValue
-# CHECK-DAG: <<Cst0:i\d+>> IntConstant 0
-# CHECK-DAG: <<Cst1:i\d+>> IntConstant 1
-# CHECK-DAG: <<Cst5:i\d+>> IntConstant 5
-# CHECK-DAG: <<Cst7:i\d+>> IntConstant 7
+## CHECK-START: int TestCase.testInnerLoop(int, boolean, boolean) dead_code_elimination_final (before)
+## CHECK-DAG: <<ArgX:i\d+>> ParameterValue
+## CHECK-DAG: <<ArgY:z\d+>> ParameterValue
+## CHECK-DAG: <<ArgZ:z\d+>> ParameterValue
+## CHECK-DAG: <<Cst0:i\d+>> IntConstant 0
+## CHECK-DAG: <<Cst1:i\d+>> IntConstant 1
+## CHECK-DAG: <<Cst5:i\d+>> IntConstant 5
+## CHECK-DAG: <<Cst7:i\d+>> IntConstant 7
#
-# CHECK-DAG: <<PhiX:i\d+>> Phi [<<ArgX>>,<<Add5:i\d+>>,<<Add7:i\d+>>] loop:<<HeaderY:B\d+>>
-# CHECK-DAG: <<PhiZ1:i\d+>> Phi [<<ArgZ>>,<<XorZ:i\d+>>,<<PhiZ1>>] loop:<<HeaderY>>
-# CHECK-DAG: If [<<ArgY>>] loop:<<HeaderY>>
+## CHECK-DAG: <<PhiX:i\d+>> Phi [<<ArgX>>,<<Add5:i\d+>>,<<Add7:i\d+>>] loop:<<HeaderY:B\d+>>
+## CHECK-DAG: <<PhiZ1:i\d+>> Phi [<<ArgZ>>,<<XorZ:i\d+>>,<<PhiZ1>>] loop:<<HeaderY>>
+## CHECK-DAG: If [<<ArgY>>] loop:<<HeaderY>>
#
-# ### Inner loop ###
-# CHECK-DAG: <<PhiZ2:i\d+>> Phi [<<PhiZ1>>,<<XorZ>>] loop:<<HeaderZ:B\d+>>
-# CHECK-DAG: <<XorZ>> Xor [<<PhiZ2>>,<<Cst1>>] loop:<<HeaderZ>>
-# CHECK-DAG: <<CondZ:z\d+>> Equal [<<XorZ>>,<<Cst0>>] loop:<<HeaderZ>>
-# CHECK-DAG: If [<<CondZ>>] loop:<<HeaderZ>>
+# ### Inner loop ###
+## CHECK-DAG: <<PhiZ2:i\d+>> Phi [<<PhiZ1>>,<<XorZ>>] loop:<<HeaderZ:B\d+>>
+## CHECK-DAG: <<XorZ>> Xor [<<PhiZ2>>,<<Cst1>>] loop:<<HeaderZ>>
+## CHECK-DAG: <<CondZ:z\d+>> Equal [<<XorZ>>,<<Cst0>>] loop:<<HeaderZ>>
+## CHECK-DAG: If [<<CondZ>>] loop:<<HeaderZ>>
#
-# CHECK-DAG: <<Add5>> Add [<<PhiX>>,<<Cst5>>] loop:<<HeaderY>>
-# CHECK-DAG: <<Add7>> Add [<<PhiX>>,<<Cst7>>] loop:<<HeaderY>>
-# CHECK-DAG: Return [<<PhiX>>] loop:none
+## CHECK-DAG: <<Add5>> Add [<<PhiX>>,<<Cst5>>] loop:<<HeaderY>>
+## CHECK-DAG: <<Add7>> Add [<<PhiX>>,<<Cst7>>] loop:<<HeaderY>>
+## CHECK-DAG: Return [<<PhiX>>] loop:none
-# CHECK-START: int TestCase.testInnerLoop(int, boolean, boolean) dead_code_elimination_final (after)
-# CHECK-DAG: <<ArgX:i\d+>> ParameterValue
-# CHECK-DAG: <<ArgY:z\d+>> ParameterValue
-# CHECK-DAG: <<ArgZ:z\d+>> ParameterValue
-# CHECK-DAG: <<Cst0:i\d+>> IntConstant 0
-# CHECK-DAG: <<Cst1:i\d+>> IntConstant 1
-# CHECK-DAG: <<Cst7:i\d+>> IntConstant 7
+## CHECK-START: int TestCase.testInnerLoop(int, boolean, boolean) dead_code_elimination_final (after)
+## CHECK-DAG: <<ArgX:i\d+>> ParameterValue
+## CHECK-DAG: <<ArgY:z\d+>> ParameterValue
+## CHECK-DAG: <<ArgZ:z\d+>> ParameterValue
+## CHECK-DAG: <<Cst0:i\d+>> IntConstant 0
+## CHECK-DAG: <<Cst1:i\d+>> IntConstant 1
+## CHECK-DAG: <<Cst7:i\d+>> IntConstant 7
#
-# CHECK-DAG: <<PhiX:i\d+>> Phi [<<ArgX>>,<<Add7:i\d+>>] loop:<<HeaderY:B\d+>>
-# CHECK-DAG: If [<<ArgY>>] loop:<<HeaderY>>
-# CHECK-DAG: <<Add7>> Add [<<PhiX>>,<<Cst7>>] loop:<<HeaderY>>
+## CHECK-DAG: <<PhiX:i\d+>> Phi [<<ArgX>>,<<Add7:i\d+>>] loop:<<HeaderY:B\d+>>
+## CHECK-DAG: If [<<ArgY>>] loop:<<HeaderY>>
+## CHECK-DAG: <<Add7>> Add [<<PhiX>>,<<Cst7>>] loop:<<HeaderY>>
#
-# ### Inner loop ###
-# CHECK-DAG: <<PhiZ:i\d+>> Phi [<<ArgZ>>,<<XorZ:i\d+>>] loop:<<HeaderZ:B\d+>>
-# CHECK-DAG: <<XorZ>> Xor [<<PhiZ>>,<<Cst1>>] loop:<<HeaderZ>>
-# CHECK-DAG: <<CondZ:z\d+>> Equal [<<XorZ>>,<<Cst0>>] loop:<<HeaderZ>>
-# CHECK-DAG: If [<<CondZ>>] loop:<<HeaderZ>>
+# ### Inner loop ###
+## CHECK-DAG: <<PhiZ:i\d+>> Phi [<<ArgZ>>,<<XorZ:i\d+>>] loop:<<HeaderZ:B\d+>>
+## CHECK-DAG: <<XorZ>> Xor [<<PhiZ>>,<<Cst1>>] loop:<<HeaderZ>>
+## CHECK-DAG: <<CondZ:z\d+>> Equal [<<XorZ>>,<<Cst0>>] loop:<<HeaderZ>>
+## CHECK-DAG: If [<<CondZ>>] loop:<<HeaderZ>>
#
-# CHECK-DAG: Return [<<PhiX>>] loop:none
+## CHECK-DAG: Return [<<PhiX>>] loop:none
.method public static testInnerLoop(IZZ)I
.registers 4
diff --git a/test/486-checker-must-do-null-check/src/Main.java b/test/486-checker-must-do-null-check/src/Main.java
index f285566..ea72718 100644
--- a/test/486-checker-must-do-null-check/src/Main.java
+++ b/test/486-checker-must-do-null-check/src/Main.java
@@ -15,8 +15,8 @@
*/
public class Main {
- // CHECK-START: void Main.InstanceOfPreChecked(java.lang.Object) instruction_simplifier (after)
- // CHECK: InstanceOf must_do_null_check:false
+ /// CHECK-START: void Main.InstanceOfPreChecked(java.lang.Object) instruction_simplifier (after)
+ /// CHECK: InstanceOf must_do_null_check:false
public void InstanceOfPreChecked(Object o) throws Exception {
o.toString();
if (o instanceof Main) {
@@ -24,23 +24,23 @@
}
}
- // CHECK-START: void Main.InstanceOf(java.lang.Object) instruction_simplifier (after)
- // CHECK: InstanceOf must_do_null_check:true
+ /// CHECK-START: void Main.InstanceOf(java.lang.Object) instruction_simplifier (after)
+ /// CHECK: InstanceOf must_do_null_check:true
public void InstanceOf(Object o) throws Exception {
if (o instanceof Main) {
throw new Exception();
}
}
- // CHECK-START: void Main.CheckCastPreChecked(java.lang.Object) instruction_simplifier (after)
- // CHECK: CheckCast must_do_null_check:false
+ /// CHECK-START: void Main.CheckCastPreChecked(java.lang.Object) instruction_simplifier (after)
+ /// CHECK: CheckCast must_do_null_check:false
public void CheckCastPreChecked(Object o) {
o.toString();
((Main)o).Bar();
}
- // CHECK-START: void Main.CheckCast(java.lang.Object) instruction_simplifier (after)
- // CHECK: CheckCast must_do_null_check:true
+ /// CHECK-START: void Main.CheckCast(java.lang.Object) instruction_simplifier (after)
+ /// CHECK: CheckCast must_do_null_check:true
public void CheckCast(Object o) {
((Main)o).Bar();
}
diff --git a/tools/art b/tools/art
index f167a73..2ee8940 100644
--- a/tools/art
+++ b/tools/art
@@ -97,7 +97,7 @@
-XXlib:$LIBART \
-Xnorelocate \
-Ximage:$ANDROID_ROOT/framework/core.art \
- -Xcompiler-option --include-debug-symbols \
+ -Xcompiler-option --generate-debug-info \
"$@"
EXIT_STATUS=$?
diff --git a/tools/buildbot-build.sh b/tools/buildbot-build.sh
new file mode 100755
index 0000000..77e6b1a
--- /dev/null
+++ b/tools/buildbot-build.sh
@@ -0,0 +1,77 @@
+#!/bin/bash
+#
+# Copyright (C) 2015 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+if [ ! -d art ]; then
+ echo "Script needs to be run at the root of the android tree"
+ exit 1
+fi
+
+common_targets="vogar vogar.jar core-tests apache-harmony-jdwp-tests-hostdex out/host/linux-x86/bin/adb jsr166-tests"
+android_root="/data/local/tmp/system"
+linker="linker"
+mode="target"
+j_arg="-j$(nproc)"
+make_command=
+
+if [[ "$TARGET_PRODUCT" == "armv8" ]]; then
+ linker="linker64"
+fi
+
+if [[ "$ART_TEST_ANDROID_ROOT" != "" ]]; then
+ android_root="$ART_TEST_ANDROID_ROOT"
+fi
+
+while true; do
+ if [[ "$1" == "--host" ]]; then
+ mode="host"
+ shift
+ elif [[ "$1" == "--target" ]]; then
+ mode="target"
+ shift
+ elif [[ "$1" == "--32" ]]; then
+ linker="linker"
+ shift
+ elif [[ "$1" == "--64" ]]; then
+ linker="linker64"
+ shift
+ elif [[ "$1" == "--android-root" ]]; then
+ shift
+ android_root=$1
+ shift
+ elif [[ "$1" == -j* ]]; then
+ j_arg=$1
+ shift
+ elif [[ "$1" == "" ]]; then
+ break
+ fi
+done
+
+if [[ $mode == "host" ]]; then
+ make_command="make $j_arg build-art-host-tests $common_targets"
+ echo "Executing $make_command"
+ $make_command
+elif [[ $mode == "target" ]]; then
+ # We need to provide our own linker in case the linker on the device
+ # is out of date.
+ env="TARGET_GLOBAL_LDFLAGS=-Wl,-dynamic-linker=$android_root/bin/$linker"
+ # Use '-e' to force the override of TARGET_GLOBAL_LDFLAGS.
+ # Also, we build extra tools that will be used by tests, so that
+ # they are compiled with our own linker.
+ make_command="make -e $j_arg build-art-target-tests $common_targets libjavacrypto linker toybox toolbox sh"
+ echo "Executing env $env $make_command"
+ env $env $make_command
+fi
+
diff --git a/tools/checker/file_format/checker/parser.py b/tools/checker/file_format/checker/parser.py
index 4eed391..33735cb 100644
--- a/tools/checker/file_format/checker/parser.py
+++ b/tools/checker/file_format/checker/parser.py
@@ -12,18 +12,22 @@
# See the License for the specific language governing permissions and
# limitations under the License.
+from common.logger import Logger
from file_format.common import SplitStream
from file_format.checker.struct import CheckerFile, TestCase, TestAssertion, RegexExpression
import re
+def __isCheckerLine(line):
+ return line.startswith("///") or line.startswith("##")
+
def __extractLine(prefix, line):
""" Attempts to parse a check line. The regex searches for a comment symbol
followed by the CHECK keyword, given attribute and a colon at the very
beginning of the line. Whitespaces are ignored.
"""
rIgnoreWhitespace = r"\s*"
- rCommentSymbols = [r"//", r"#"]
+ rCommentSymbols = [r"///", r"##"]
regexPrefix = rIgnoreWhitespace + \
r"(" + r"|".join(rCommentSymbols) + r")" + \
rIgnoreWhitespace + \
@@ -37,13 +41,16 @@
else:
return None
-def __processLine(line, lineNo, prefix):
+def __processLine(line, lineNo, prefix, fileName):
""" This function is invoked on each line of the check file and returns a pair
which instructs the parser how the line should be handled. If the line is
to be included in the current check group, it is returned in the first
value. If the line starts a new check group, the name of the group is
returned in the second value.
"""
+ if not __isCheckerLine(line):
+ return None, None
+
# Lines beginning with 'CHECK-START' start a new test case.
startLine = __extractLine(prefix + "-START", line)
if startLine is not None:
@@ -69,8 +76,7 @@
if notLine is not None:
return (notLine, TestAssertion.Variant.Not, lineNo), None
- # Other lines are ignored.
- return None, None
+ Logger.fail("Checker assertion could not be parsed", fileName, lineNo)
def __isMatchAtStart(match):
""" Tests if the given Match occurred at the beginning of the line. """
@@ -137,9 +143,9 @@
def ParseCheckerStream(fileName, prefix, stream):
checkerFile = CheckerFile(fileName)
- fnProcessLine = lambda line, lineNo: __processLine(line, lineNo, prefix)
+ fnProcessLine = lambda line, lineNo: __processLine(line, lineNo, prefix, fileName)
fnLineOutsideChunk = lambda line, lineNo: \
- Logger.fail("C1visualizer line not inside a group", fileName, lineNo)
+ Logger.fail("Checker line not inside a group", fileName, lineNo)
for caseName, caseLines, startLineNo in SplitStream(stream, fnProcessLine, fnLineOutsideChunk):
testCase = TestCase(checkerFile, caseName, startLineNo)
for caseLine in caseLines:
diff --git a/tools/checker/file_format/checker/test.py b/tools/checker/file_format/checker/test.py
index 453deed..ff24cc1 100644
--- a/tools/checker/file_format/checker/test.py
+++ b/tools/checker/file_format/checker/test.py
@@ -26,43 +26,56 @@
class CheckerParser_PrefixTest(unittest.TestCase):
def tryParse(self, string):
- checkerText = u"// CHECK-START: pass\n" + ToUnicode(string)
- checkFile = ParseCheckerStream("<test-file>", "CHECK", io.StringIO(checkerText))
+ checkerText = u"/// CHECK-START: pass\n" + ToUnicode(string)
+ return ParseCheckerStream("<test-file>", "CHECK", io.StringIO(checkerText))
+
+ def assertParses(self, string):
+ checkFile = self.tryParse(string)
self.assertEqual(len(checkFile.testCases), 1)
- testCase = checkFile.testCases[0]
- return len(testCase.assertions) != 0
+ self.assertNotEqual(len(checkFile.testCases[0].assertions), 0)
+
+ def assertIgnored(self, string):
+ checkFile = self.tryParse(string)
+ self.assertEqual(len(checkFile.testCases), 1)
+ self.assertEqual(len(checkFile.testCases[0].assertions), 0)
+
+ def assertInvalid(self, string):
+ with self.assertRaises(CheckerException):
+ self.tryParse(string)
+
+ def test_ValidFormat(self):
+ self.assertParses("///CHECK:foo")
+ self.assertParses("##CHECK:bar")
def test_InvalidFormat(self):
- self.assertFalse(self.tryParse("CHECK"))
- self.assertFalse(self.tryParse(":CHECK"))
- self.assertFalse(self.tryParse("CHECK:"))
- self.assertFalse(self.tryParse("//CHECK"))
- self.assertFalse(self.tryParse("#CHECK"))
+ self.assertIgnored("CHECK")
+ self.assertIgnored(":CHECK")
+ self.assertIgnored("CHECK:")
+ self.assertIgnored("//CHECK")
+ self.assertIgnored("#CHECK")
+ self.assertInvalid("///CHECK")
+ self.assertInvalid("##CHECK")
- self.assertTrue(self.tryParse("//CHECK:foo"))
- self.assertTrue(self.tryParse("#CHECK:bar"))
-
- def test_InvalidLabel(self):
- self.assertFalse(self.tryParse("//ACHECK:foo"))
- self.assertFalse(self.tryParse("#ACHECK:foo"))
+ def test_InvalidPrefix(self):
+ self.assertInvalid("///ACHECK:foo")
+ self.assertInvalid("##ACHECK:foo")
def test_NotFirstOnTheLine(self):
- self.assertFalse(self.tryParse("A// CHECK: foo"))
- self.assertFalse(self.tryParse("A # CHECK: foo"))
- self.assertFalse(self.tryParse("// // CHECK: foo"))
- self.assertFalse(self.tryParse("# # CHECK: foo"))
+ self.assertIgnored("A/// CHECK: foo")
+ self.assertIgnored("A # CHECK: foo")
+ self.assertInvalid("/// /// CHECK: foo")
+ self.assertInvalid("## ## CHECK: foo")
def test_WhitespaceAgnostic(self):
- self.assertTrue(self.tryParse(" //CHECK: foo"))
- self.assertTrue(self.tryParse("// CHECK: foo"))
- self.assertTrue(self.tryParse(" //CHECK: foo"))
- self.assertTrue(self.tryParse("// CHECK: foo"))
-
+ self.assertParses(" ///CHECK: foo")
+ self.assertParses("/// CHECK: foo")
+ self.assertParses(" ///CHECK: foo")
+ self.assertParses("/// CHECK: foo")
class CheckerParser_RegexExpressionTest(unittest.TestCase):
def parseAssertion(self, string, variant=""):
- checkerText = u"// CHECK-START: pass\n// CHECK" + ToUnicode(variant) + u": " + ToUnicode(string)
+ checkerText = u"/// CHECK-START: pass\n/// CHECK" + ToUnicode(variant) + u": " + ToUnicode(string)
checkerFile = ParseCheckerStream("<test-file>", "CHECK", io.StringIO(checkerText))
self.assertEqual(len(checkerFile.testCases), 1)
testCase = checkerFile.testCases[0]
@@ -204,9 +217,9 @@
def test_SingleGroup(self):
self.assertParsesTo(
"""
- // CHECK-START: Example Group
- // CHECK: foo
- // CHECK: bar
+ /// CHECK-START: Example Group
+ /// CHECK: foo
+ /// CHECK: bar
""",
[ ( "Example Group", [ ("foo", TestAssertion.Variant.InOrder),
("bar", TestAssertion.Variant.InOrder) ] ) ])
@@ -214,12 +227,12 @@
def test_MultipleGroups(self):
self.assertParsesTo(
"""
- // CHECK-START: Example Group1
- // CHECK: foo
- // CHECK: bar
- // CHECK-START: Example Group2
- // CHECK: abc
- // CHECK: def
+ /// CHECK-START: Example Group1
+ /// CHECK: foo
+ /// CHECK: bar
+ /// CHECK-START: Example Group2
+ /// CHECK: abc
+ /// CHECK: def
""",
[ ( "Example Group1", [ ("foo", TestAssertion.Variant.InOrder),
("bar", TestAssertion.Variant.InOrder) ] ),
@@ -229,14 +242,14 @@
def test_AssertionVariants(self):
self.assertParsesTo(
"""
- // CHECK-START: Example Group
- // CHECK: foo1
- // CHECK: foo2
- // CHECK-NEXT: foo3
- // CHECK-NEXT: foo4
- // CHECK-NOT: bar
- // CHECK-DAG: abc
- // CHECK-DAG: def
+ /// CHECK-START: Example Group
+ /// CHECK: foo1
+ /// CHECK: foo2
+ /// CHECK-NEXT: foo3
+ /// CHECK-NEXT: foo4
+ /// CHECK-NOT: bar
+ /// CHECK-DAG: abc
+ /// CHECK-DAG: def
""",
[ ( "Example Group", [ ("foo1", TestAssertion.Variant.InOrder),
("foo2", TestAssertion.Variant.InOrder),
@@ -250,20 +263,20 @@
with self.assertRaises(CheckerException):
self.parse(
"""
- // CHECK-START: Example Group
- // CHECK-DAG: foo
- // CHECK-NEXT: bar
+ /// CHECK-START: Example Group
+ /// CHECK-DAG: foo
+ /// CHECK-NEXT: bar
""")
with self.assertRaises(CheckerException):
self.parse(
"""
- // CHECK-START: Example Group
- // CHECK-NOT: foo
- // CHECK-NEXT: bar
+ /// CHECK-START: Example Group
+ /// CHECK-NOT: foo
+ /// CHECK-NEXT: bar
""")
with self.assertRaises(CheckerException):
self.parse(
"""
- // CHECK-START: Example Group
- // CHECK-NEXT: bar
+ /// CHECK-START: Example Group
+ /// CHECK-NEXT: bar
""")
diff --git a/tools/checker/match/test.py b/tools/checker/match/test.py
index 348c1d2..ca748c7 100644
--- a/tools/checker/match/test.py
+++ b/tools/checker/match/test.py
@@ -105,7 +105,7 @@
def assertMatches(self, checkerString, c1String):
checkerString = \
"""
- // CHECK-START: MyMethod MyPass
+ /// CHECK-START: MyMethod MyPass
""" + checkerString
c1String = \
"""
@@ -131,18 +131,18 @@
self.assertMatches(checkerString, c1String)
def test_Text(self):
- self.assertMatches("// CHECK: foo bar", "foo bar")
- self.assertDoesNotMatch("// CHECK: foo bar", "abc def")
+ self.assertMatches("/// CHECK: foo bar", "foo bar")
+ self.assertDoesNotMatch("/// CHECK: foo bar", "abc def")
def test_Pattern(self):
- self.assertMatches("// CHECK: abc {{de.}}", "abc de#")
- self.assertDoesNotMatch("// CHECK: abc {{de.}}", "abc d#f")
+ self.assertMatches("/// CHECK: abc {{de.}}", "abc de#")
+ self.assertDoesNotMatch("/// CHECK: abc {{de.}}", "abc d#f")
def test_Variables(self):
self.assertMatches(
"""
- // CHECK: foo<<X:.>>bar
- // CHECK: abc<<X>>def
+ /// CHECK: foo<<X:.>>bar
+ /// CHECK: abc<<X>>def
""",
"""
foo0bar
@@ -150,9 +150,9 @@
""")
self.assertMatches(
"""
- // CHECK: foo<<X:([0-9]+)>>bar
- // CHECK: abc<<X>>def
- // CHECK: ### <<X>> ###
+ /// CHECK: foo<<X:([0-9]+)>>bar
+ /// CHECK: abc<<X>>def
+ /// CHECK: ### <<X>> ###
""",
"""
foo1234bar
@@ -161,8 +161,8 @@
""")
self.assertDoesNotMatch(
"""
- // CHECK: foo<<X:([0-9]+)>>bar
- // CHECK: abc<<X>>def
+ /// CHECK: foo<<X:([0-9]+)>>bar
+ /// CHECK: abc<<X>>def
""",
"""
foo1234bar
@@ -170,16 +170,16 @@
""")
def test_WholeWordMustMatch(self):
- self.assertMatches("// CHECK: b{{.}}r", "abc bar def")
- self.assertDoesNotMatch("// CHECK: b{{.}}r", "abc Xbar def")
- self.assertDoesNotMatch("// CHECK: b{{.}}r", "abc barX def")
- self.assertDoesNotMatch("// CHECK: b{{.}}r", "abc b r def")
+ self.assertMatches("/// CHECK: b{{.}}r", "abc bar def")
+ self.assertDoesNotMatch("/// CHECK: b{{.}}r", "abc Xbar def")
+ self.assertDoesNotMatch("/// CHECK: b{{.}}r", "abc barX def")
+ self.assertDoesNotMatch("/// CHECK: b{{.}}r", "abc b r def")
def test_InOrderAssertions(self):
self.assertMatches(
"""
- // CHECK: foo
- // CHECK: bar
+ /// CHECK: foo
+ /// CHECK: bar
""",
"""
foo
@@ -187,8 +187,8 @@
""")
self.assertDoesNotMatch(
"""
- // CHECK: foo
- // CHECK: bar
+ /// CHECK: foo
+ /// CHECK: bar
""",
"""
bar
@@ -198,10 +198,10 @@
def test_NextLineAssertions(self):
self.assertMatches(
"""
- // CHECK: foo
- // CHECK-NEXT: bar
- // CHECK-NEXT: abc
- // CHECK: def
+ /// CHECK: foo
+ /// CHECK-NEXT: bar
+ /// CHECK-NEXT: abc
+ /// CHECK: def
""",
"""
foo
@@ -211,9 +211,9 @@
""")
self.assertMatches(
"""
- // CHECK: foo
- // CHECK-NEXT: bar
- // CHECK: def
+ /// CHECK: foo
+ /// CHECK-NEXT: bar
+ /// CHECK: def
""",
"""
foo
@@ -223,8 +223,8 @@
""")
self.assertDoesNotMatch(
"""
- // CHECK: foo
- // CHECK-NEXT: bar
+ /// CHECK: foo
+ /// CHECK-NEXT: bar
""",
"""
foo
@@ -234,8 +234,8 @@
self.assertDoesNotMatch(
"""
- // CHECK: foo
- // CHECK-NEXT: bar
+ /// CHECK: foo
+ /// CHECK-NEXT: bar
""",
"""
bar
@@ -246,8 +246,8 @@
def test_DagAssertions(self):
self.assertMatches(
"""
- // CHECK-DAG: foo
- // CHECK-DAG: bar
+ /// CHECK-DAG: foo
+ /// CHECK-DAG: bar
""",
"""
foo
@@ -255,8 +255,8 @@
""")
self.assertMatches(
"""
- // CHECK-DAG: foo
- // CHECK-DAG: bar
+ /// CHECK-DAG: foo
+ /// CHECK-DAG: bar
""",
"""
bar
@@ -266,10 +266,10 @@
def test_DagAssertionsScope(self):
self.assertMatches(
"""
- // CHECK: foo
- // CHECK-DAG: abc
- // CHECK-DAG: def
- // CHECK: bar
+ /// CHECK: foo
+ /// CHECK-DAG: abc
+ /// CHECK-DAG: def
+ /// CHECK: bar
""",
"""
foo
@@ -279,10 +279,10 @@
""")
self.assertDoesNotMatch(
"""
- // CHECK: foo
- // CHECK-DAG: abc
- // CHECK-DAG: def
- // CHECK: bar
+ /// CHECK: foo
+ /// CHECK-DAG: abc
+ /// CHECK-DAG: def
+ /// CHECK: bar
""",
"""
foo
@@ -292,10 +292,10 @@
""")
self.assertDoesNotMatch(
"""
- // CHECK: foo
- // CHECK-DAG: abc
- // CHECK-DAG: def
- // CHECK: bar
+ /// CHECK: foo
+ /// CHECK-DAG: abc
+ /// CHECK-DAG: def
+ /// CHECK: bar
""",
"""
foo
@@ -307,7 +307,7 @@
def test_NotAssertions(self):
self.assertMatches(
"""
- // CHECK-NOT: foo
+ /// CHECK-NOT: foo
""",
"""
abc
@@ -315,7 +315,7 @@
""")
self.assertDoesNotMatch(
"""
- // CHECK-NOT: foo
+ /// CHECK-NOT: foo
""",
"""
abc foo
@@ -323,8 +323,8 @@
""")
self.assertDoesNotMatch(
"""
- // CHECK-NOT: foo
- // CHECK-NOT: bar
+ /// CHECK-NOT: foo
+ /// CHECK-NOT: bar
""",
"""
abc
@@ -334,9 +334,9 @@
def test_NotAssertionsScope(self):
self.assertMatches(
"""
- // CHECK: abc
- // CHECK-NOT: foo
- // CHECK: def
+ /// CHECK: abc
+ /// CHECK-NOT: foo
+ /// CHECK: def
""",
"""
abc
@@ -344,9 +344,9 @@
""")
self.assertMatches(
"""
- // CHECK: abc
- // CHECK-NOT: foo
- // CHECK: def
+ /// CHECK: abc
+ /// CHECK-NOT: foo
+ /// CHECK: def
""",
"""
abc
@@ -355,9 +355,9 @@
""")
self.assertDoesNotMatch(
"""
- // CHECK: abc
- // CHECK-NOT: foo
- // CHECK: def
+ /// CHECK: abc
+ /// CHECK-NOT: foo
+ /// CHECK: def
""",
"""
abc
@@ -368,8 +368,8 @@
def test_LineOnlyMatchesOnce(self):
self.assertMatches(
"""
- // CHECK-DAG: foo
- // CHECK-DAG: foo
+ /// CHECK-DAG: foo
+ /// CHECK-DAG: foo
""",
"""
foo
@@ -378,8 +378,8 @@
""")
self.assertDoesNotMatch(
"""
- // CHECK-DAG: foo
- // CHECK-DAG: foo
+ /// CHECK-DAG: foo
+ /// CHECK-DAG: foo
""",
"""
foo
diff --git a/tools/libcore_failures.txt b/tools/libcore_failures.txt
index 064abc1..b053f0d 100644
--- a/tools/libcore_failures.txt
+++ b/tools/libcore_failures.txt
@@ -36,14 +36,20 @@
names: ["libcore.io.OsTest#testUnixDomainSockets_in_file_system"]
},
{
- description: "Failures needing investigation",
+ description: "Issue with incorrect device time (1970)",
result: EXEC_FAILED,
modes: [device],
names: ["libcore.java.util.TimeZoneTest#testDisplayNames",
"libcore.java.util.TimeZoneTest#test_useDaylightTime_Taiwan",
- "org.apache.harmony.tests.java.util.DateTest#test_Constructor",
- "org.apache.harmony.tests.java.util.ScannerTest#test_Constructor_LReadableByteChannel",
- "org.apache.harmony.tests.java.util.TimeZoneTest#test_hasSameRules_Ljava_util_TimeZone"]
+ "org.apache.harmony.tests.java.util.TimeZoneTest#test_hasSameRules_Ljava_util_TimeZone"],
+ bug: 20879084
+},
+{
+ description: "Issue with incorrect device time (1970). Test assumes that DateTime.now()
+ is greater then a date in 1998.",
+ result: EXEC_FAILED,
+ modes: [device],
+ names: ["org.apache.harmony.tests.java.util.DateTest#test_Constructor"]
},
{
description: "Failing due to a locale problem on hammerhead.",
@@ -75,7 +81,8 @@
"libcore.net.NetworkSecurityPolicyTest#testCleartextTrafficPolicyWithJarHttpURLConnection",
"org.apache.harmony.luni.tests.internal.net.www.protocol.http.HttpURLConnectionTest",
"org.apache.harmony.luni.tests.internal.net.www.protocol.https.HttpsURLConnectionTest",
- "org.apache.harmony.luni.tests.java.net.URLConnectionTest"
+ "org.apache.harmony.luni.tests.java.net.URLConnectionTest",
+ "org.apache.harmony.tests.java.util.ScannerTest#test_Constructor_LReadableByteChannel"
]
},
{