Merge "Fix double-exception in super-class method validation."
diff --git a/Android.mk b/Android.mk
index 98d5fb1..54a33b2 100644
--- a/Android.mk
+++ b/Android.mk
@@ -382,10 +382,10 @@
# Rules for building all dependencies for tests.
.PHONY: build-art-host-tests
-build-art-host-tests: build-art-host $(ART_TEST_HOST_RUN_TEST_DEPENDENCIES) $(ART_TEST_HOST_GTEST_DEPENDENCIES)
+build-art-host-tests: build-art-host $(TEST_ART_RUN_TEST_DEPENDENCIES) $(ART_TEST_HOST_RUN_TEST_DEPENDENCIES) $(ART_TEST_HOST_GTEST_DEPENDENCIES)
.PHONY: build-art-target-tests
-build-art-target-tests: build-art-target $(TEST_ART_TARGET_SYNC_DEPS)
+build-art-target-tests: build-art-target $(TEST_ART_RUN_TEST_DEPENDENCIES) $(TEST_ART_TARGET_SYNC_DEPS)
########################################################################
# targets to switch back and forth from libdvm to libart
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_builder.h b/compiler/elf_builder.h
index 5b74c94..fa69434 100644
--- a/compiler/elf_builder.h
+++ b/compiler/elf_builder.h
@@ -267,7 +267,7 @@
class StrtabSection FINAL : public Section {
public:
StrtabSection(const std::string& name, Elf_Word flags)
- : Section(name, SHT_STRTAB, flags, nullptr, 0, 1, 1) {
+ : Section(name, SHT_STRTAB, flags, nullptr, 0, 1, 0) {
buffer_.reserve(4 * KB);
// The first entry of strtab must be empty string.
buffer_ += '\0';
@@ -503,7 +503,7 @@
text_(".text", SHT_PROGBITS, SHF_ALLOC | SHF_EXECINSTR,
nullptr, 0, kPageSize, 0, text_size, text_writer),
bss_(".bss", bss_size),
- dynamic_(".dynamic", &dynsym_),
+ dynamic_(".dynamic", &dynstr_),
strtab_(".strtab", 0),
symtab_(".symtab", SHT_SYMTAB, 0, &strtab_),
shstrtab_(".shstrtab", 0) {
@@ -645,11 +645,10 @@
// It is easiest to just reserve a fixed amount of space for them.
constexpr size_t kMaxProgramHeaders = 8;
constexpr size_t kProgramHeadersOffset = sizeof(Elf_Ehdr);
- constexpr size_t kProgramHeadersSize = sizeof(Elf_Phdr) * kMaxProgramHeaders;
// Layout of all sections - determine the final file offsets and addresses.
// This must be done after we have built all sections and know their size.
- Elf_Off file_offset = kProgramHeadersOffset + kProgramHeadersSize;
+ Elf_Off file_offset = kProgramHeadersOffset + sizeof(Elf_Phdr) * kMaxProgramHeaders;
Elf_Addr load_address = file_offset;
std::vector<Elf_Shdr> section_headers;
section_headers.reserve(1u + sections.size());
@@ -686,8 +685,7 @@
// PT_LOAD does the mapping. Other PT_* types allow the program to locate
// interesting parts of memory and their addresses overlap with PT_LOAD.
std::vector<Elf_Phdr> program_headers;
- program_headers.push_back(MakeProgramHeader(PT_PHDR, PF_R,
- kProgramHeadersOffset, kProgramHeadersSize, sizeof(Elf_Word)));
+ program_headers.push_back(Elf_Phdr()); // Placeholder for PT_PHDR.
// Create the main LOAD R segment which spans all sections up to .rodata.
const Elf_Shdr* rodata = rodata_.GetHeader();
program_headers.push_back(MakeProgramHeader(PT_LOAD, PF_R,
@@ -713,6 +711,9 @@
program_headers.push_back(MakeProgramHeader(PT_GNU_EH_FRAME, PF_R, *eh_frame_hdr));
}
}
+ DCHECK_EQ(program_headers[0].p_type, 0u); // Check placeholder.
+ program_headers[0] = MakeProgramHeader(PT_PHDR, PF_R,
+ kProgramHeadersOffset, program_headers.size() * sizeof(Elf_Phdr), sizeof(Elf_Word));
CHECK_LE(program_headers.size(), kMaxProgramHeaders);
// Create the main ELF header.
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/builder.cc b/compiler/optimizing/builder.cc
index 41c1d2c..411a5aa 100644
--- a/compiler/optimizing/builder.cc
+++ b/compiler/optimizing/builder.cc
@@ -652,8 +652,8 @@
DCHECK((optimized_invoke_type == invoke_type) || (optimized_invoke_type != kDirect)
|| compiler_driver_->GetCompilerOptions().GetCompilePic());
bool is_recursive =
- (target_method.dex_method_index == dex_compilation_unit_->GetDexMethodIndex());
- DCHECK(!is_recursive || (target_method.dex_file == dex_compilation_unit_->GetDexFile()));
+ (target_method.dex_method_index == outer_compilation_unit_->GetDexMethodIndex())
+ && (target_method.dex_file == outer_compilation_unit_->GetDexFile());
if (optimized_invoke_type == kStatic) {
ScopedObjectAccess soa(Thread::Current());
@@ -828,13 +828,17 @@
value,
field_type,
resolved_field->GetOffset(),
- resolved_field->IsVolatile()));
+ resolved_field->IsVolatile(),
+ field_index,
+ *dex_file_));
} else {
current_block_->AddInstruction(new (arena_) HInstanceFieldGet(
current_block_->GetLastInstruction(),
field_type,
resolved_field->GetOffset(),
- resolved_field->IsVolatile()));
+ resolved_field->IsVolatile(),
+ field_index,
+ *dex_file_));
UpdateLocal(source_or_dest_reg, current_block_->GetLastInstruction());
}
@@ -939,13 +943,20 @@
temps.Add(cls);
HInstruction* value = LoadLocal(source_or_dest_reg, field_type);
DCHECK_EQ(value->GetType(), field_type);
- current_block_->AddInstruction(
- new (arena_) HStaticFieldSet(cls, value, field_type, resolved_field->GetOffset(),
- resolved_field->IsVolatile()));
+ current_block_->AddInstruction(new (arena_) HStaticFieldSet(cls,
+ value,
+ field_type,
+ resolved_field->GetOffset(),
+ resolved_field->IsVolatile(),
+ field_index,
+ *dex_file_));
} else {
- current_block_->AddInstruction(
- new (arena_) HStaticFieldGet(cls, field_type, resolved_field->GetOffset(),
- resolved_field->IsVolatile()));
+ current_block_->AddInstruction(new (arena_) HStaticFieldGet(cls,
+ field_type,
+ resolved_field->GetOffset(),
+ resolved_field->IsVolatile(),
+ field_index,
+ *dex_file_));
UpdateLocal(source_or_dest_reg, current_block_->GetLastInstruction());
}
return true;
@@ -2151,13 +2162,15 @@
}
case Instruction::CONST_STRING: {
- current_block_->AddInstruction(new (arena_) HLoadString(instruction.VRegB_21c(), dex_pc));
+ current_block_->AddInstruction(
+ new (arena_) HLoadString(graph_->GetCurrentMethod(), instruction.VRegB_21c(), dex_pc));
UpdateLocal(instruction.VRegA_21c(), current_block_->GetLastInstruction());
break;
}
case Instruction::CONST_STRING_JUMBO: {
- current_block_->AddInstruction(new (arena_) HLoadString(instruction.VRegB_31c(), dex_pc));
+ current_block_->AddInstruction(
+ new (arena_) HLoadString(graph_->GetCurrentMethod(), instruction.VRegB_31c(), dex_pc));
UpdateLocal(instruction.VRegA_31c(), current_block_->GetLastInstruction());
break;
}
diff --git a/compiler/optimizing/code_generator_arm.cc b/compiler/optimizing/code_generator_arm.cc
index ab3b6b0..bd1f134 100644
--- a/compiler/optimizing/code_generator_arm.cc
+++ b/compiler/optimizing/code_generator_arm.cc
@@ -4031,6 +4031,7 @@
void LocationsBuilderARM::VisitLoadString(HLoadString* load) {
LocationSummary* locations =
new (GetGraph()->GetArena()) LocationSummary(load, LocationSummary::kCallOnSlowPath);
+ locations->SetInAt(0, Location::RequiresRegister());
locations->SetOut(Location::RequiresRegister());
}
@@ -4038,9 +4039,11 @@
SlowPathCodeARM* slow_path = new (GetGraph()->GetArena()) LoadStringSlowPathARM(load);
codegen_->AddSlowPath(slow_path);
- Register out = load->GetLocations()->Out().AsRegister<Register>();
- codegen_->LoadCurrentMethod(out);
- __ LoadFromOffset(kLoadWord, out, out, mirror::ArtMethod::DeclaringClassOffset().Int32Value());
+ LocationSummary* locations = load->GetLocations();
+ Register out = locations->Out().AsRegister<Register>();
+ Register current_method = locations->InAt(0).AsRegister<Register>();
+ __ LoadFromOffset(
+ kLoadWord, out, current_method, mirror::ArtMethod::DeclaringClassOffset().Int32Value());
__ LoadFromOffset(kLoadWord, out, out, mirror::Class::DexCacheStringsOffset().Int32Value());
__ LoadFromOffset(kLoadWord, out, out, CodeGenerator::GetCacheOffset(load->GetStringIndex()));
__ cmp(out, ShifterOperand(0));
diff --git a/compiler/optimizing/code_generator_arm64.cc b/compiler/optimizing/code_generator_arm64.cc
index 04c38f6..cf5a8fb 100644
--- a/compiler/optimizing/code_generator_arm64.cc
+++ b/compiler/optimizing/code_generator_arm64.cc
@@ -2397,6 +2397,7 @@
void LocationsBuilderARM64::VisitLoadString(HLoadString* load) {
LocationSummary* locations =
new (GetGraph()->GetArena()) LocationSummary(load, LocationSummary::kCallOnSlowPath);
+ locations->SetInAt(0, Location::RequiresRegister());
locations->SetOut(Location::RequiresRegister());
}
@@ -2405,8 +2406,8 @@
codegen_->AddSlowPath(slow_path);
Register out = OutputRegister(load);
- codegen_->LoadCurrentMethod(out);
- __ Ldr(out, HeapOperand(out, mirror::ArtMethod::DeclaringClassOffset()));
+ Register current_method = InputRegisterAt(load, 0);
+ __ Ldr(out, HeapOperand(current_method, mirror::ArtMethod::DeclaringClassOffset()));
__ Ldr(out, HeapOperand(out, mirror::Class::DexCacheStringsOffset()));
__ Ldr(out, HeapOperand(out, CodeGenerator::GetCacheOffset(load->GetStringIndex())));
__ Cbz(out, slow_path->GetEntryLabel());
diff --git a/compiler/optimizing/code_generator_x86.cc b/compiler/optimizing/code_generator_x86.cc
index 1688efc..81c3526 100644
--- a/compiler/optimizing/code_generator_x86.cc
+++ b/compiler/optimizing/code_generator_x86.cc
@@ -4352,6 +4352,7 @@
void LocationsBuilderX86::VisitLoadString(HLoadString* load) {
LocationSummary* locations =
new (GetGraph()->GetArena()) LocationSummary(load, LocationSummary::kCallOnSlowPath);
+ locations->SetInAt(0, Location::RequiresRegister());
locations->SetOut(Location::RequiresRegister());
}
@@ -4359,9 +4360,10 @@
SlowPathCodeX86* slow_path = new (GetGraph()->GetArena()) LoadStringSlowPathX86(load);
codegen_->AddSlowPath(slow_path);
- Register out = load->GetLocations()->Out().AsRegister<Register>();
- codegen_->LoadCurrentMethod(out);
- __ movl(out, Address(out, mirror::ArtMethod::DeclaringClassOffset().Int32Value()));
+ LocationSummary* locations = load->GetLocations();
+ Register out = locations->Out().AsRegister<Register>();
+ Register current_method = locations->InAt(0).AsRegister<Register>();
+ __ movl(out, Address(current_method, mirror::ArtMethod::DeclaringClassOffset().Int32Value()));
__ movl(out, Address(out, mirror::Class::DexCacheStringsOffset().Int32Value()));
__ movl(out, Address(out, CodeGenerator::GetCacheOffset(load->GetStringIndex())));
__ testl(out, out);
diff --git a/compiler/optimizing/code_generator_x86_64.cc b/compiler/optimizing/code_generator_x86_64.cc
index 7847701..f8125c6 100644
--- a/compiler/optimizing/code_generator_x86_64.cc
+++ b/compiler/optimizing/code_generator_x86_64.cc
@@ -4190,6 +4190,7 @@
void LocationsBuilderX86_64::VisitLoadString(HLoadString* load) {
LocationSummary* locations =
new (GetGraph()->GetArena()) LocationSummary(load, LocationSummary::kCallOnSlowPath);
+ locations->SetInAt(0, Location::RequiresRegister());
locations->SetOut(Location::RequiresRegister());
}
@@ -4197,9 +4198,10 @@
SlowPathCodeX86_64* slow_path = new (GetGraph()->GetArena()) LoadStringSlowPathX86_64(load);
codegen_->AddSlowPath(slow_path);
- CpuRegister out = load->GetLocations()->Out().AsRegister<CpuRegister>();
- codegen_->LoadCurrentMethod(CpuRegister(out));
- __ movl(out, Address(out, mirror::ArtMethod::DeclaringClassOffset().Int32Value()));
+ LocationSummary* locations = load->GetLocations();
+ CpuRegister out = locations->Out().AsRegister<CpuRegister>();
+ CpuRegister current_method = locations->InAt(0).AsRegister<CpuRegister>();
+ __ movl(out, Address(current_method, mirror::ArtMethod::DeclaringClassOffset().Int32Value()));
__ movl(out, Address(out, mirror::Class::DexCacheStringsOffset().Int32Value()));
__ movl(out, Address(out, CodeGenerator::GetCacheOffset(load->GetStringIndex())));
__ testl(out, out);
diff --git a/compiler/optimizing/graph_visualizer.cc b/compiler/optimizing/graph_visualizer.cc
index 7da4f2d..fd2e4e8 100644
--- a/compiler/optimizing/graph_visualizer.cc
+++ b/compiler/optimizing/graph_visualizer.cc
@@ -280,6 +280,13 @@
<< instance_of->MustDoNullCheck() << std::noboolalpha;
}
+ void VisitInvokeStaticOrDirect(HInvokeStaticOrDirect* invoke) OVERRIDE {
+ StartAttributeStream("dex_file_index") << invoke->GetDexMethodIndex();
+ StartAttributeStream("recursive") << std::boolalpha
+ << invoke->IsRecursive()
+ << std::noboolalpha;
+ }
+
bool IsPass(const char* name) {
return strcmp(pass_name_, name) == 0;
}
diff --git a/compiler/optimizing/gvn_test.cc b/compiler/optimizing/gvn_test.cc
index c3ce7e1..d8a09ff 100644
--- a/compiler/optimizing/gvn_test.cc
+++ b/compiler/optimizing/gvn_test.cc
@@ -40,23 +40,40 @@
graph->AddBlock(block);
entry->AddSuccessor(block);
- block->AddInstruction(
- new (&allocator) HInstanceFieldGet(parameter, Primitive::kPrimNot,
- MemberOffset(42), false));
- block->AddInstruction(
- new (&allocator) HInstanceFieldGet(parameter, Primitive::kPrimNot,
- MemberOffset(42), false));
+ block->AddInstruction(new (&allocator) HInstanceFieldGet(parameter,
+ Primitive::kPrimNot,
+ MemberOffset(42),
+ false,
+ kUnknownFieldIndex,
+ graph->GetDexFile()));
+ block->AddInstruction(new (&allocator) HInstanceFieldGet(parameter,
+ Primitive::kPrimNot,
+ MemberOffset(42),
+ false,
+ kUnknownFieldIndex,
+ graph->GetDexFile()));
HInstruction* to_remove = block->GetLastInstruction();
- block->AddInstruction(
- new (&allocator) HInstanceFieldGet(parameter, Primitive::kPrimNot,
- MemberOffset(43), false));
+ block->AddInstruction(new (&allocator) HInstanceFieldGet(parameter,
+ Primitive::kPrimNot,
+ MemberOffset(43),
+ false,
+ kUnknownFieldIndex,
+ graph->GetDexFile()));
HInstruction* different_offset = block->GetLastInstruction();
// Kill the value.
- block->AddInstruction(new (&allocator) HInstanceFieldSet(
- parameter, parameter, Primitive::kPrimNot, MemberOffset(42), false));
- block->AddInstruction(
- new (&allocator) HInstanceFieldGet(parameter, Primitive::kPrimNot,
- MemberOffset(42), false));
+ block->AddInstruction(new (&allocator) HInstanceFieldSet(parameter,
+ parameter,
+ Primitive::kPrimNot,
+ MemberOffset(42),
+ false,
+ kUnknownFieldIndex,
+ graph->GetDexFile()));
+ block->AddInstruction(new (&allocator) HInstanceFieldGet(parameter,
+ Primitive::kPrimNot,
+ MemberOffset(42),
+ false,
+ kUnknownFieldIndex,
+ graph->GetDexFile()));
HInstruction* use_after_kill = block->GetLastInstruction();
block->AddInstruction(new (&allocator) HExit());
@@ -88,9 +105,12 @@
HBasicBlock* block = new (&allocator) HBasicBlock(graph);
graph->AddBlock(block);
entry->AddSuccessor(block);
- block->AddInstruction(
- new (&allocator) HInstanceFieldGet(parameter, Primitive::kPrimBoolean,
- MemberOffset(42), false));
+ block->AddInstruction(new (&allocator) HInstanceFieldGet(parameter,
+ Primitive::kPrimBoolean,
+ MemberOffset(42),
+ false,
+ kUnknownFieldIndex,
+ graph->GetDexFile()));
block->AddInstruction(new (&allocator) HIf(block->GetLastInstruction()));
HBasicBlock* then = new (&allocator) HBasicBlock(graph);
@@ -105,17 +125,26 @@
then->AddSuccessor(join);
else_->AddSuccessor(join);
- then->AddInstruction(
- new (&allocator) HInstanceFieldGet(parameter, Primitive::kPrimBoolean,
- MemberOffset(42), false));
+ then->AddInstruction(new (&allocator) HInstanceFieldGet(parameter,
+ Primitive::kPrimBoolean,
+ MemberOffset(42),
+ false,
+ kUnknownFieldIndex,
+ graph->GetDexFile()));
then->AddInstruction(new (&allocator) HGoto());
- else_->AddInstruction(
- new (&allocator) HInstanceFieldGet(parameter, Primitive::kPrimBoolean,
- MemberOffset(42), false));
+ else_->AddInstruction(new (&allocator) HInstanceFieldGet(parameter,
+ Primitive::kPrimBoolean,
+ MemberOffset(42),
+ false,
+ kUnknownFieldIndex,
+ graph->GetDexFile()));
else_->AddInstruction(new (&allocator) HGoto());
- join->AddInstruction(
- new (&allocator) HInstanceFieldGet(parameter, Primitive::kPrimBoolean,
- MemberOffset(42), false));
+ join->AddInstruction(new (&allocator) HInstanceFieldGet(parameter,
+ Primitive::kPrimBoolean,
+ MemberOffset(42),
+ false,
+ kUnknownFieldIndex,
+ graph->GetDexFile()));
join->AddInstruction(new (&allocator) HExit());
graph->TryBuildingSsa();
@@ -144,9 +173,12 @@
HBasicBlock* block = new (&allocator) HBasicBlock(graph);
graph->AddBlock(block);
entry->AddSuccessor(block);
- block->AddInstruction(
- new (&allocator) HInstanceFieldGet(parameter, Primitive::kPrimBoolean,
- MemberOffset(42), false));
+ block->AddInstruction(new (&allocator) HInstanceFieldGet(parameter,
+ Primitive::kPrimBoolean,
+ MemberOffset(42),
+ false,
+ kUnknownFieldIndex,
+ graph->GetDexFile()));
block->AddInstruction(new (&allocator) HGoto());
HBasicBlock* loop_header = new (&allocator) HBasicBlock(graph);
@@ -161,26 +193,40 @@
loop_header->AddSuccessor(exit);
loop_body->AddSuccessor(loop_header);
- loop_header->AddInstruction(
- new (&allocator) HInstanceFieldGet(parameter, Primitive::kPrimBoolean,
- MemberOffset(42), false));
+ loop_header->AddInstruction(new (&allocator) HInstanceFieldGet(parameter,
+ Primitive::kPrimBoolean,
+ MemberOffset(42),
+ false,
+ kUnknownFieldIndex,
+ graph->GetDexFile()));
HInstruction* field_get_in_loop_header = loop_header->GetLastInstruction();
loop_header->AddInstruction(new (&allocator) HIf(block->GetLastInstruction()));
// Kill inside the loop body to prevent field gets inside the loop header
// and the body to be GVN'ed.
- loop_body->AddInstruction(new (&allocator) HInstanceFieldSet(
- parameter, parameter, Primitive::kPrimNot, MemberOffset(42), false));
+ loop_body->AddInstruction(new (&allocator) HInstanceFieldSet(parameter,
+ parameter,
+ Primitive::kPrimNot,
+ MemberOffset(42),
+ false,
+ kUnknownFieldIndex,
+ graph->GetDexFile()));
HInstruction* field_set = loop_body->GetLastInstruction();
- loop_body->AddInstruction(
- new (&allocator) HInstanceFieldGet(parameter, Primitive::kPrimBoolean,
- MemberOffset(42), false));
+ loop_body->AddInstruction(new (&allocator) HInstanceFieldGet(parameter,
+ Primitive::kPrimBoolean,
+ MemberOffset(42),
+ false,
+ kUnknownFieldIndex,
+ graph->GetDexFile()));
HInstruction* field_get_in_loop_body = loop_body->GetLastInstruction();
loop_body->AddInstruction(new (&allocator) HGoto());
- exit->AddInstruction(
- new (&allocator) HInstanceFieldGet(parameter, Primitive::kPrimBoolean,
- MemberOffset(42), false));
+ exit->AddInstruction(new (&allocator) HInstanceFieldGet(parameter,
+ Primitive::kPrimBoolean,
+ MemberOffset(42),
+ false,
+ kUnknownFieldIndex,
+ graph->GetDexFile()));
HInstruction* field_get_in_exit = exit->GetLastInstruction();
exit->AddInstruction(new (&allocator) HExit());
@@ -266,8 +312,13 @@
// Check that the loops don't have side effects.
{
// Make one block with a side effect.
- entry->AddInstruction(new (&allocator) HInstanceFieldSet(
- parameter, parameter, Primitive::kPrimNot, MemberOffset(42), false));
+ entry->AddInstruction(new (&allocator) HInstanceFieldSet(parameter,
+ parameter,
+ Primitive::kPrimNot,
+ MemberOffset(42),
+ false,
+ kUnknownFieldIndex,
+ graph->GetDexFile()));
SideEffectsAnalysis side_effects(graph);
side_effects.Run();
@@ -280,8 +331,13 @@
// Check that the side effects of the outer loop does not affect the inner loop.
{
outer_loop_body->InsertInstructionBefore(
- new (&allocator) HInstanceFieldSet(
- parameter, parameter, Primitive::kPrimNot, MemberOffset(42), false),
+ new (&allocator) HInstanceFieldSet(parameter,
+ parameter,
+ Primitive::kPrimNot,
+ MemberOffset(42),
+ false,
+ kUnknownFieldIndex,
+ graph->GetDexFile()),
outer_loop_body->GetLastInstruction());
SideEffectsAnalysis side_effects(graph);
@@ -297,8 +353,13 @@
{
outer_loop_body->RemoveInstruction(outer_loop_body->GetFirstInstruction());
inner_loop_body->InsertInstructionBefore(
- new (&allocator) HInstanceFieldSet(
- parameter, parameter, Primitive::kPrimNot, MemberOffset(42), false),
+ new (&allocator) HInstanceFieldSet(parameter,
+ parameter,
+ Primitive::kPrimNot,
+ MemberOffset(42),
+ false,
+ kUnknownFieldIndex,
+ graph->GetDexFile()),
inner_loop_body->GetLastInstruction());
SideEffectsAnalysis side_effects(graph);
diff --git a/compiler/optimizing/inliner.cc b/compiler/optimizing/inliner.cc
index 997f980..15f3deb 100644
--- a/compiler/optimizing/inliner.cc
+++ b/compiler/optimizing/inliner.cc
@@ -36,8 +36,8 @@
namespace art {
-static constexpr int kMaxInlineCodeUnits = 100;
-static constexpr int kDepthLimit = 5;
+static constexpr int kMaxInlineCodeUnits = 18;
+static constexpr int kDepthLimit = 3;
void HInliner::Run() {
if (graph_->IsDebuggable()) {
@@ -46,8 +46,15 @@
return;
}
const GrowableArray<HBasicBlock*>& blocks = graph_->GetReversePostOrder();
+ HBasicBlock* next_block = blocks.Get(0);
for (size_t i = 0; i < blocks.Size(); ++i) {
- HBasicBlock* block = blocks.Get(i);
+ // Because we are changing the graph when inlining, we need to remember the next block.
+ // This avoids doing the inlining work again on the inlined blocks.
+ if (blocks.Get(i) != next_block) {
+ continue;
+ }
+ HBasicBlock* block = next_block;
+ next_block = (i == blocks.Size() - 1) ? nullptr : blocks.Get(i + 1);
for (HInstruction* instruction = block->GetFirstInstruction(); instruction != nullptr;) {
HInstruction* next = instruction->GetNext();
HInvokeStaticOrDirect* call = instruction->AsInvokeStaticOrDirect();
@@ -90,10 +97,10 @@
return false;
}
- bool can_use_dex_cache = true;
+ bool same_dex_file = true;
const DexFile& outer_dex_file = *outer_compilation_unit_.GetDexFile();
if (resolved_method->GetDexFile()->GetLocation().compare(outer_dex_file.GetLocation()) != 0) {
- can_use_dex_cache = false;
+ same_dex_file = false;
}
const DexFile::CodeItem* code_item = resolved_method->GetCodeItem();
@@ -140,7 +147,7 @@
return false;
}
- if (!TryBuildAndInline(resolved_method, invoke_instruction, method_index, can_use_dex_cache)) {
+ if (!TryBuildAndInline(resolved_method, invoke_instruction, method_index, same_dex_file)) {
return false;
}
@@ -152,7 +159,7 @@
bool HInliner::TryBuildAndInline(Handle<mirror::ArtMethod> resolved_method,
HInvoke* invoke_instruction,
uint32_t method_index,
- bool can_use_dex_cache) const {
+ bool same_dex_file) const {
ScopedObjectAccess soa(Thread::Current());
const DexFile::CodeItem* code_item = resolved_method->GetCodeItem();
const DexFile& caller_dex_file = *caller_compilation_unit_.GetDexFile();
@@ -254,6 +261,31 @@
inliner.Run();
}
+ // TODO: We should abort only if all predecessors throw. However,
+ // HGraph::InlineInto currently does not handle an exit block with
+ // a throw predecessor.
+ HBasicBlock* exit_block = callee_graph->GetExitBlock();
+ if (exit_block == nullptr) {
+ VLOG(compiler) << "Method " << PrettyMethod(method_index, caller_dex_file)
+ << " could not be inlined because it has an infinite loop";
+ resolved_method->SetShouldNotInline();
+ return false;
+ }
+
+ bool has_throw_predecessor = false;
+ for (size_t i = 0, e = exit_block->GetPredecessors().Size(); i < e; ++i) {
+ if (exit_block->GetPredecessors().Get(i)->GetLastInstruction()->IsThrow()) {
+ has_throw_predecessor = true;
+ break;
+ }
+ }
+ if (has_throw_predecessor) {
+ VLOG(compiler) << "Method " << PrettyMethod(method_index, caller_dex_file)
+ << " could not be inlined because one branch always throws";
+ resolved_method->SetShouldNotInline();
+ return false;
+ }
+
HReversePostOrderIterator it(*callee_graph);
it.Advance(); // Past the entry block, it does not contain instructions that prevent inlining.
for (; !it.Done(); it.Advance()) {
@@ -269,27 +301,24 @@
!instr_it.Done();
instr_it.Advance()) {
HInstruction* current = instr_it.Current();
- if (current->IsSuspendCheck()) {
- continue;
- }
- if (current->CanThrow()) {
+ if (current->IsInvokeInterface()) {
+ // Disable inlining of interface calls. The cost in case of entering the
+ // resolution conflict is currently too high.
VLOG(compiler) << "Method " << PrettyMethod(method_index, caller_dex_file)
- << " could not be inlined because " << current->DebugName()
- << " can throw";
+ << " could not be inlined because it has an interface call.";
resolved_method->SetShouldNotInline();
return false;
}
- if (current->NeedsEnvironment()) {
+ if (!same_dex_file && current->NeedsEnvironment()) {
VLOG(compiler) << "Method " << PrettyMethod(method_index, caller_dex_file)
<< " could not be inlined because " << current->DebugName()
- << " needs an environment";
- resolved_method->SetShouldNotInline();
+ << " needs an environment and is in a different dex file";
return false;
}
- if (!can_use_dex_cache && current->NeedsDexCache()) {
+ if (!same_dex_file && current->NeedsDexCache()) {
VLOG(compiler) << "Method " << PrettyMethod(method_index, caller_dex_file)
<< " could not be inlined because " << current->DebugName()
<< " it is in a different dex file and requires access to the dex cache";
@@ -302,10 +331,6 @@
callee_graph->InlineInto(graph_, invoke_instruction);
- if (callee_graph->HasBoundsChecks()) {
- graph_->SetHasBoundsChecks(true);
- }
-
return true;
}
diff --git a/compiler/optimizing/inliner.h b/compiler/optimizing/inliner.h
index 1dbc7d3..09a36c6 100644
--- a/compiler/optimizing/inliner.h
+++ b/compiler/optimizing/inliner.h
@@ -51,7 +51,7 @@
bool TryBuildAndInline(Handle<mirror::ArtMethod> resolved_method,
HInvoke* invoke_instruction,
uint32_t method_index,
- bool can_use_dex_cache) const;
+ bool same_dex_file) const;
const DexCompilationUnit& outer_compilation_unit_;
const DexCompilationUnit& caller_compilation_unit_;
diff --git a/compiler/optimizing/nodes.cc b/compiler/optimizing/nodes.cc
index 80d4b4a..06f6a7f 100644
--- a/compiler/optimizing/nodes.cc
+++ b/compiler/optimizing/nodes.cc
@@ -1314,6 +1314,29 @@
void HGraph::InlineInto(HGraph* outer_graph, HInvoke* invoke) {
DCHECK(HasExitBlock()) << "Unimplemented scenario";
+ // Update the environments in this graph to have the invoke's environment
+ // as parent.
+ {
+ HReversePostOrderIterator it(*this);
+ it.Advance(); // Skip the entry block, we do not need to update the entry's suspend check.
+ for (; !it.Done(); it.Advance()) {
+ HBasicBlock* block = it.Current();
+ for (HInstructionIterator instr_it(block->GetInstructions());
+ !instr_it.Done();
+ instr_it.Advance()) {
+ HInstruction* current = instr_it.Current();
+ if (current->NeedsEnvironment()) {
+ current->GetEnvironment()->SetAndCopyParentChain(
+ outer_graph->GetArena(), invoke->GetEnvironment());
+ }
+ }
+ }
+ }
+ outer_graph->UpdateMaximumNumberOfOutVRegs(GetMaximumNumberOfOutVRegs());
+ if (HasBoundsChecks()) {
+ outer_graph->SetHasBoundsChecks(true);
+ }
+
if (GetBlocks().Size() == 3) {
// Simple case of an entry block, a body block, and an exit block.
// Put the body block's instruction into `invoke`'s block.
diff --git a/compiler/optimizing/nodes.h b/compiler/optimizing/nodes.h
index 869809d..6c2506e 100644
--- a/compiler/optimizing/nodes.h
+++ b/compiler/optimizing/nodes.h
@@ -61,6 +61,8 @@
static constexpr uint32_t kMaxIntShiftValue = 0x1f;
static constexpr uint64_t kMaxLongShiftValue = 0x3f;
+static constexpr uint32_t kUnknownFieldIndex = static_cast<uint32_t>(-1);
+
static constexpr InvokeType kInvalidInvokeType = static_cast<InvokeType>(-1);
enum IfCondition {
@@ -143,6 +145,7 @@
dex_file_(dex_file),
method_idx_(method_idx),
invoke_type_(invoke_type),
+ in_ssa_form_(false),
should_generate_constructor_barrier_(should_generate_constructor_barrier),
cached_null_constant_(nullptr),
cached_int_constants_(std::less<int32_t>(), arena->Adapter()),
@@ -174,6 +177,7 @@
// users remaining when being visited.
if (!AnalyzeNaturalLoops()) return false;
TransformToSsa();
+ in_ssa_form_ = true;
return true;
}
@@ -216,11 +220,16 @@
maximum_number_of_out_vregs_ = new_value;
}
+ void UpdateMaximumNumberOfOutVRegs(uint16_t other_value) {
+ maximum_number_of_out_vregs_ = std::max(maximum_number_of_out_vregs_, other_value);
+ }
+
void UpdateTemporariesVRegSlots(size_t slots) {
temporaries_vreg_slots_ = std::max(slots, temporaries_vreg_slots_);
}
size_t GetTemporariesVRegSlots() const {
+ DCHECK(!in_ssa_form_);
return temporaries_vreg_slots_;
}
@@ -229,6 +238,7 @@
}
uint16_t GetNumberOfVRegs() const {
+ DCHECK(!in_ssa_form_);
return number_of_vregs_;
}
@@ -237,6 +247,7 @@
}
uint16_t GetNumberOfLocalVRegs() const {
+ DCHECK(!in_ssa_form_);
return number_of_vregs_ - number_of_in_vregs_;
}
@@ -381,6 +392,11 @@
// If inlined, this encodes how the callee is being invoked.
const InvokeType invoke_type_;
+ // Whether the graph has been transformed to SSA form. Only used
+ // in debug mode to ensure we are not using properties only valid
+ // for non-SSA form (like the number of temporaries).
+ bool in_ssa_form_;
+
const bool should_generate_constructor_barrier_;
// Cached constants.
@@ -1121,14 +1137,16 @@
const DexFile& dex_file,
uint32_t method_idx,
uint32_t dex_pc,
- InvokeType invoke_type)
+ InvokeType invoke_type,
+ HInstruction* holder)
: vregs_(arena, number_of_vregs),
locations_(arena, number_of_vregs),
parent_(nullptr),
dex_file_(dex_file),
method_idx_(method_idx),
dex_pc_(dex_pc),
- invoke_type_(invoke_type) {
+ invoke_type_(invoke_type),
+ holder_(holder) {
vregs_.SetSize(number_of_vregs);
for (size_t i = 0; i < number_of_vregs; i++) {
vregs_.Put(i, HUserRecord<HEnvironment*>());
@@ -1140,19 +1158,24 @@
}
}
- HEnvironment(ArenaAllocator* arena, const HEnvironment& to_copy)
+ HEnvironment(ArenaAllocator* arena, const HEnvironment& to_copy, HInstruction* holder)
: HEnvironment(arena,
to_copy.Size(),
to_copy.GetDexFile(),
to_copy.GetMethodIdx(),
to_copy.GetDexPc(),
- to_copy.GetInvokeType()) {}
+ to_copy.GetInvokeType(),
+ holder) {}
void SetAndCopyParentChain(ArenaAllocator* allocator, HEnvironment* parent) {
- parent_ = new (allocator) HEnvironment(allocator, *parent);
- parent_->CopyFrom(parent);
- if (parent->GetParent() != nullptr) {
- parent_->SetAndCopyParentChain(allocator, parent->GetParent());
+ if (parent_ != nullptr) {
+ parent_->SetAndCopyParentChain(allocator, parent);
+ } else {
+ parent_ = new (allocator) HEnvironment(allocator, *parent, holder_);
+ parent_->CopyFrom(parent);
+ if (parent->GetParent() != nullptr) {
+ parent_->SetAndCopyParentChain(allocator, parent->GetParent());
+ }
}
}
@@ -1202,6 +1225,10 @@
return dex_file_;
}
+ HInstruction* GetHolder() const {
+ return holder_;
+ }
+
private:
// Record instructions' use entries of this environment for constant-time removal.
// It should only be called by HInstruction when a new environment use is added.
@@ -1219,6 +1246,10 @@
const uint32_t dex_pc_;
const InvokeType invoke_type_;
+ // The instruction that holds this environment. Only used in debug mode
+ // to ensure the graph is consistent.
+ HInstruction* const holder_;
+
friend class HInstruction;
DISALLOW_COPY_AND_ASSIGN(HEnvironment);
@@ -1425,13 +1456,18 @@
HEnvironment* GetEnvironment() const { return environment_; }
// Set the `environment_` field. Raw because this method does not
// update the uses lists.
- void SetRawEnvironment(HEnvironment* environment) { environment_ = environment; }
+ void SetRawEnvironment(HEnvironment* environment) {
+ DCHECK(environment_ == nullptr);
+ DCHECK_EQ(environment->GetHolder(), this);
+ environment_ = environment;
+ }
// Set the environment of this instruction, copying it from `environment`. While
// copying, the uses lists are being updated.
void CopyEnvironmentFrom(HEnvironment* environment) {
+ DCHECK(environment_ == nullptr);
ArenaAllocator* allocator = GetBlock()->GetGraph()->GetArena();
- environment_ = new (allocator) HEnvironment(allocator, *environment);
+ environment_ = new (allocator) HEnvironment(allocator, *environment, this);
environment_->CopyFrom(environment);
if (environment->GetParent() != nullptr) {
environment_->SetAndCopyParentChain(allocator, environment->GetParent());
@@ -1440,8 +1476,9 @@
void CopyEnvironmentFromWithLoopPhiAdjustment(HEnvironment* environment,
HBasicBlock* block) {
+ DCHECK(environment_ == nullptr);
ArenaAllocator* allocator = GetBlock()->GetGraph()->GetArena();
- environment_ = new (allocator) HEnvironment(allocator, *environment);
+ environment_ = new (allocator) HEnvironment(allocator, *environment, this);
environment_->CopyFromWithLoopPhiAdjustment(environment, block);
if (environment->GetParent() != nullptr) {
environment_->SetAndCopyParentChain(allocator, environment->GetParent());
@@ -2420,6 +2457,12 @@
intrinsic_ = intrinsic;
}
+ bool IsInlined() const {
+ return GetEnvironment()->GetParent() != nullptr;
+ }
+
+ bool CanThrow() const OVERRIDE { return true; }
+
DECLARE_INSTRUCTION(Invoke);
protected:
@@ -3160,17 +3203,29 @@
class FieldInfo : public ValueObject {
public:
- FieldInfo(MemberOffset field_offset, Primitive::Type field_type, bool is_volatile)
- : field_offset_(field_offset), field_type_(field_type), is_volatile_(is_volatile) {}
+ FieldInfo(MemberOffset field_offset,
+ Primitive::Type field_type,
+ bool is_volatile,
+ uint32_t index,
+ const DexFile& dex_file)
+ : field_offset_(field_offset),
+ field_type_(field_type),
+ is_volatile_(is_volatile),
+ index_(index),
+ dex_file_(dex_file) {}
MemberOffset GetFieldOffset() const { return field_offset_; }
Primitive::Type GetFieldType() const { return field_type_; }
+ uint32_t GetFieldIndex() const { return index_; }
+ const DexFile& GetDexFile() const { return dex_file_; }
bool IsVolatile() const { return is_volatile_; }
private:
const MemberOffset field_offset_;
const Primitive::Type field_type_;
const bool is_volatile_;
+ uint32_t index_;
+ const DexFile& dex_file_;
};
class HInstanceFieldGet : public HExpression<1> {
@@ -3178,9 +3233,11 @@
HInstanceFieldGet(HInstruction* value,
Primitive::Type field_type,
MemberOffset field_offset,
- bool is_volatile)
+ bool is_volatile,
+ uint32_t field_idx,
+ const DexFile& dex_file)
: HExpression(field_type, SideEffects::DependsOnSomething()),
- field_info_(field_offset, field_type, is_volatile) {
+ field_info_(field_offset, field_type, is_volatile, field_idx, dex_file) {
SetRawInputAt(0, value);
}
@@ -3218,9 +3275,11 @@
HInstruction* value,
Primitive::Type field_type,
MemberOffset field_offset,
- bool is_volatile)
+ bool is_volatile,
+ uint32_t field_idx,
+ const DexFile& dex_file)
: HTemplateInstruction(SideEffects::ChangesSomething()),
- field_info_(field_offset, field_type, is_volatile),
+ field_info_(field_offset, field_type, is_volatile, field_idx, dex_file),
value_can_be_null_(true) {
SetRawInputAt(0, object);
SetRawInputAt(1, value);
@@ -3544,12 +3603,14 @@
DISALLOW_COPY_AND_ASSIGN(HLoadClass);
};
-class HLoadString : public HExpression<0> {
+class HLoadString : public HExpression<1> {
public:
- HLoadString(uint32_t string_index, uint32_t dex_pc)
+ HLoadString(HCurrentMethod* current_method, uint32_t string_index, uint32_t dex_pc)
: HExpression(Primitive::kPrimNot, SideEffects::None()),
string_index_(string_index),
- dex_pc_(dex_pc) {}
+ dex_pc_(dex_pc) {
+ SetRawInputAt(0, current_method);
+ }
bool CanBeMoved() const OVERRIDE { return true; }
@@ -3614,9 +3675,11 @@
HStaticFieldGet(HInstruction* cls,
Primitive::Type field_type,
MemberOffset field_offset,
- bool is_volatile)
+ bool is_volatile,
+ uint32_t field_idx,
+ const DexFile& dex_file)
: HExpression(field_type, SideEffects::DependsOnSomething()),
- field_info_(field_offset, field_type, is_volatile) {
+ field_info_(field_offset, field_type, is_volatile, field_idx, dex_file) {
SetRawInputAt(0, cls);
}
@@ -3651,9 +3714,11 @@
HInstruction* value,
Primitive::Type field_type,
MemberOffset field_offset,
- bool is_volatile)
+ bool is_volatile,
+ uint32_t field_idx,
+ const DexFile& dex_file)
: HTemplateInstruction(SideEffects::ChangesSomething()),
- field_info_(field_offset, field_type, is_volatile),
+ field_info_(field_offset, field_type, is_volatile, field_idx, dex_file),
value_can_be_null_(true) {
SetRawInputAt(0, cls);
SetRawInputAt(1, value);
diff --git a/compiler/optimizing/nodes_test.cc b/compiler/optimizing/nodes_test.cc
index 782cde4..fef77aa 100644
--- a/compiler/optimizing/nodes_test.cc
+++ b/compiler/optimizing/nodes_test.cc
@@ -51,7 +51,7 @@
exit_block->AddInstruction(new (&allocator) HExit());
HEnvironment* environment = new (&allocator) HEnvironment(
- &allocator, 1, graph->GetDexFile(), graph->GetMethodIdx(), 0, kStatic);
+ &allocator, 1, graph->GetDexFile(), graph->GetMethodIdx(), 0, kStatic, null_check);
null_check->SetRawEnvironment(environment);
environment->SetRawEnvAt(0, parameter);
parameter->AddEnvUseAt(null_check->GetEnvironment(), 0);
@@ -132,7 +132,7 @@
ASSERT_TRUE(parameter1->GetUses().HasOnlyOneUse());
HEnvironment* environment = new (&allocator) HEnvironment(
- &allocator, 1, graph->GetDexFile(), graph->GetMethodIdx(), 0, kStatic);
+ &allocator, 1, graph->GetDexFile(), graph->GetMethodIdx(), 0, kStatic, with_environment);
GrowableArray<HInstruction*> array(&allocator, 1);
array.Add(parameter1);
@@ -143,13 +143,13 @@
ASSERT_TRUE(parameter1->GetEnvUses().HasOnlyOneUse());
HEnvironment* parent1 = new (&allocator) HEnvironment(
- &allocator, 1, graph->GetDexFile(), graph->GetMethodIdx(), 0, kStatic);
+ &allocator, 1, graph->GetDexFile(), graph->GetMethodIdx(), 0, kStatic, nullptr);
parent1->CopyFrom(array);
ASSERT_EQ(parameter1->GetEnvUses().SizeSlow(), 2u);
HEnvironment* parent2 = new (&allocator) HEnvironment(
- &allocator, 1, graph->GetDexFile(), graph->GetMethodIdx(), 0, kStatic);
+ &allocator, 1, graph->GetDexFile(), graph->GetMethodIdx(), 0, kStatic, nullptr);
parent2->CopyFrom(array);
parent1->SetAndCopyParentChain(&allocator, parent2);
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/compiler/optimizing/prepare_for_register_allocation.cc b/compiler/optimizing/prepare_for_register_allocation.cc
index 538736b..a249aa9 100644
--- a/compiler/optimizing/prepare_for_register_allocation.cc
+++ b/compiler/optimizing/prepare_for_register_allocation.cc
@@ -88,7 +88,11 @@
// The static call will initialize the class so there's no need for a clinit check if
// it's the first user.
- if (last_input == invoke->GetPrevious()) {
+ // There is one special case where we still need the clinit check, when inlining. Because
+ // currently the callee is responsible for reporting parameters to the GC, the code
+ // that walks the stack during `artQuickResolutionTrampoline` cannot be interrupted for GC.
+ // Therefore we cannot allocate any object in that code, including loading a new class.
+ if (last_input == invoke->GetPrevious() && !invoke->IsInlined()) {
last_input->SetMustGenerateClinitCheck(false);
}
@@ -102,7 +106,7 @@
// If the load class instruction is no longer used, remove it from
// the graph.
- if (!last_input->HasUses()) {
+ if (!last_input->HasUses() && !(last_input->MustGenerateClinitCheck() && invoke->IsInlined())) {
last_input->GetBlock()->RemoveInstruction(last_input);
}
}
diff --git a/compiler/optimizing/reference_type_propagation.cc b/compiler/optimizing/reference_type_propagation.cc
index 91b2e6f..f7d2ed1 100644
--- a/compiler/optimizing/reference_type_propagation.cc
+++ b/compiler/optimizing/reference_type_propagation.cc
@@ -35,17 +35,22 @@
void ReferenceTypePropagation::VisitBasicBlock(HBasicBlock* block) {
// TODO: handle other instructions that give type info
- // (Call/Field accesses/array accesses)
+ // (Call/array accesses)
// Initialize exact types first for faster convergence.
for (HInstructionIterator it(block->GetInstructions()); !it.Done(); it.Advance()) {
HInstruction* instr = it.Current();
+ // TODO: Make ReferenceTypePropagation a visitor or create a new one.
if (instr->IsNewInstance()) {
VisitNewInstance(instr->AsNewInstance());
} else if (instr->IsLoadClass()) {
VisitLoadClass(instr->AsLoadClass());
} else if (instr->IsNewArray()) {
VisitNewArray(instr->AsNewArray());
+ } else if (instr->IsInstanceFieldGet()) {
+ VisitInstanceFieldGet(instr->AsInstanceFieldGet());
+ } else if (instr->IsStaticFieldGet()) {
+ VisitStaticFieldGet(instr->AsStaticFieldGet());
}
}
@@ -161,6 +166,14 @@
}
}
+void ReferenceTypePropagation::SetClassAsTypeInfo(HInstruction* instr, mirror::Class* klass) {
+ if (klass != nullptr) {
+ ScopedObjectAccess soa(Thread::Current());
+ MutableHandle<mirror::Class> handle = handles_->NewHandle(klass);
+ instr->SetReferenceTypeInfo(ReferenceTypeInfo::Create(handle, true));
+ }
+}
+
void ReferenceTypePropagation::UpdateReferenceTypeInfo(HInstruction* instr,
uint16_t type_idx,
const DexFile& dex_file) {
@@ -169,11 +182,7 @@
ScopedObjectAccess soa(Thread::Current());
mirror::DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
// Get type from dex cache assuming it was populated by the verifier.
- mirror::Class* resolved_class = dex_cache->GetResolvedType(type_idx);
- if (resolved_class != nullptr) {
- MutableHandle<mirror::Class> handle = handles_->NewHandle(resolved_class);
- instr->SetReferenceTypeInfo(ReferenceTypeInfo::Create(handle, true));
- }
+ SetClassAsTypeInfo(instr, dex_cache->GetResolvedType(type_idx));
}
void ReferenceTypePropagation::VisitNewInstance(HNewInstance* instr) {
@@ -184,6 +193,30 @@
UpdateReferenceTypeInfo(instr, instr->GetTypeIndex(), instr->GetDexFile());
}
+void ReferenceTypePropagation::UpdateFieldAccessTypeInfo(HInstruction* instr,
+ const FieldInfo& info) {
+ // The field index is unknown only during tests.
+ if (instr->GetType() != Primitive::kPrimNot || info.GetFieldIndex() == kUnknownFieldIndex) {
+ return;
+ }
+
+ ScopedObjectAccess soa(Thread::Current());
+ ClassLinker* cl = Runtime::Current()->GetClassLinker();
+ mirror::DexCache* dex_cache = cl->FindDexCache(info.GetDexFile());
+ ArtField* field = cl->GetResolvedField(info.GetFieldIndex(), dex_cache);
+ DCHECK(field != nullptr);
+ mirror::Class* klass = field->GetType<false>();
+ SetClassAsTypeInfo(instr, klass);
+}
+
+void ReferenceTypePropagation::VisitInstanceFieldGet(HInstanceFieldGet* instr) {
+ UpdateFieldAccessTypeInfo(instr, instr->GetFieldInfo());
+}
+
+void ReferenceTypePropagation::VisitStaticFieldGet(HStaticFieldGet* instr) {
+ UpdateFieldAccessTypeInfo(instr, instr->GetFieldInfo());
+}
+
void ReferenceTypePropagation::VisitLoadClass(HLoadClass* instr) {
ScopedObjectAccess soa(Thread::Current());
mirror::DexCache* dex_cache =
diff --git a/compiler/optimizing/reference_type_propagation.h b/compiler/optimizing/reference_type_propagation.h
index 12c3362..74e425f 100644
--- a/compiler/optimizing/reference_type_propagation.h
+++ b/compiler/optimizing/reference_type_propagation.h
@@ -45,6 +45,8 @@
void VisitNewArray(HNewArray* instr);
void VisitPhi(HPhi* phi);
void VisitBasicBlock(HBasicBlock* block);
+ void UpdateFieldAccessTypeInfo(HInstruction* instr, const FieldInfo& info);
+ void SetClassAsTypeInfo(HInstruction* instr, mirror::Class* klass);
void UpdateBoundType(HBoundType* bound_type) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
void UpdatePhi(HPhi* phi) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -52,6 +54,8 @@
void BoundTypeForIfNotNull(HBasicBlock* block);
void BoundTypeForIfInstanceOf(HBasicBlock* block);
void UpdateReferenceTypeInfo(HInstruction* instr, uint16_t type_idx, const DexFile& dex_file);
+ void VisitInstanceFieldGet(HInstanceFieldGet* instr);
+ void VisitStaticFieldGet(HStaticFieldGet* instr);
void ProcessWorklist();
void AddToWorklist(HInstruction* instr);
diff --git a/compiler/optimizing/register_allocator.cc b/compiler/optimizing/register_allocator.cc
index d4ff4d8..9a859bf 100644
--- a/compiler/optimizing/register_allocator.cc
+++ b/compiler/optimizing/register_allocator.cc
@@ -1583,7 +1583,7 @@
while (env_use != nullptr && env_use->GetPosition() <= range->GetEnd()) {
DCHECK(current->CoversSlow(env_use->GetPosition())
|| (env_use->GetPosition() == range->GetEnd()));
- HEnvironment* environment = env_use->GetUser()->GetEnvironment();
+ HEnvironment* environment = env_use->GetEnvironment();
environment->SetLocationAt(env_use->GetInputIndex(), source);
env_use = env_use->GetNext();
}
diff --git a/compiler/optimizing/register_allocator_test.cc b/compiler/optimizing/register_allocator_test.cc
index b72ffb8..d07a14a 100644
--- a/compiler/optimizing/register_allocator_test.cc
+++ b/compiler/optimizing/register_allocator_test.cc
@@ -474,8 +474,12 @@
graph->AddBlock(block);
entry->AddSuccessor(block);
- HInstruction* test = new (allocator) HInstanceFieldGet(
- parameter, Primitive::kPrimBoolean, MemberOffset(22), false);
+ HInstruction* test = new (allocator) HInstanceFieldGet(parameter,
+ Primitive::kPrimBoolean,
+ MemberOffset(22),
+ false,
+ kUnknownFieldIndex,
+ graph->GetDexFile());
block->AddInstruction(test);
block->AddInstruction(new (allocator) HIf(test));
HBasicBlock* then = new (allocator) HBasicBlock(graph);
@@ -494,10 +498,18 @@
*phi = new (allocator) HPhi(allocator, 0, 0, Primitive::kPrimInt);
join->AddPhi(*phi);
- *input1 = new (allocator) HInstanceFieldGet(parameter, Primitive::kPrimInt,
- MemberOffset(42), false);
- *input2 = new (allocator) HInstanceFieldGet(parameter, Primitive::kPrimInt,
- MemberOffset(42), false);
+ *input1 = new (allocator) HInstanceFieldGet(parameter,
+ Primitive::kPrimInt,
+ MemberOffset(42),
+ false,
+ kUnknownFieldIndex,
+ graph->GetDexFile());
+*input2 = new (allocator) HInstanceFieldGet(parameter,
+ Primitive::kPrimInt,
+ MemberOffset(42),
+ false,
+ kUnknownFieldIndex,
+ graph->GetDexFile());
then->AddInstruction(*input1);
else_->AddInstruction(*input2);
join->AddInstruction(new (allocator) HExit());
@@ -604,8 +616,12 @@
graph->AddBlock(block);
entry->AddSuccessor(block);
- *field = new (allocator) HInstanceFieldGet(parameter, Primitive::kPrimInt,
- MemberOffset(42), false);
+ *field = new (allocator) HInstanceFieldGet(parameter,
+ Primitive::kPrimInt,
+ MemberOffset(42),
+ false,
+ kUnknownFieldIndex,
+ graph->GetDexFile());
block->AddInstruction(*field);
*ret = new (allocator) HReturn(*field);
block->AddInstruction(*ret);
diff --git a/compiler/optimizing/ssa_builder.cc b/compiler/optimizing/ssa_builder.cc
index c51d248..c4612af 100644
--- a/compiler/optimizing/ssa_builder.cc
+++ b/compiler/optimizing/ssa_builder.cc
@@ -548,7 +548,8 @@
GetGraph()->GetDexFile(),
GetGraph()->GetMethodIdx(),
instruction->GetDexPc(),
- GetGraph()->GetInvokeType());
+ GetGraph()->GetInvokeType(),
+ instruction);
environment->CopyFrom(*current_locals_);
instruction->SetRawEnvironment(environment);
}
diff --git a/compiler/optimizing/ssa_liveness_analysis.h b/compiler/optimizing/ssa_liveness_analysis.h
index 4b19c5b..4cbe29a 100644
--- a/compiler/optimizing/ssa_liveness_analysis.h
+++ b/compiler/optimizing/ssa_liveness_analysis.h
@@ -117,6 +117,7 @@
|| user->IsPhi()
|| (GetPosition() == user->GetLifetimePosition() + 1)
|| (GetPosition() == user->GetLifetimePosition()));
+ DCHECK(environment == nullptr || user == nullptr);
DCHECK(next_ == nullptr || next->GetPosition() >= GetPosition());
}
@@ -128,6 +129,7 @@
void SetNext(UsePosition* next) { next_ = next; }
HInstruction* GetUser() const { return user_; }
+ HEnvironment* GetEnvironment() const { return environment_; }
bool GetIsEnvironment() const { return environment_ != nullptr; }
bool IsSynthesized() const { return user_ == nullptr; }
@@ -280,7 +282,7 @@
}
DCHECK(first_use_->GetPosition() + 1 == position);
UsePosition* new_use = new (allocator_) UsePosition(
- instruction, environment, input_index, position, cursor->GetNext());
+ instruction, nullptr /* environment */, input_index, position, cursor->GetNext());
cursor->SetNext(new_use);
if (first_range_->GetEnd() == first_use_->GetPosition()) {
first_range_->end_ = position;
@@ -290,10 +292,10 @@
if (is_environment) {
first_env_use_ = new (allocator_) UsePosition(
- instruction, environment, input_index, position, first_env_use_);
+ nullptr /* instruction */, environment, input_index, position, first_env_use_);
} else {
first_use_ = new (allocator_) UsePosition(
- instruction, environment, input_index, position, first_use_);
+ instruction, nullptr /* environment */, input_index, position, first_use_);
}
if (is_environment && !keep_alive) {
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/entrypoints/entrypoint_utils-inl.h b/runtime/entrypoints/entrypoint_utils-inl.h
index 625e695..526fb8d 100644
--- a/runtime/entrypoints/entrypoint_utils-inl.h
+++ b/runtime/entrypoints/entrypoint_utils-inl.h
@@ -38,6 +38,29 @@
namespace art {
+inline mirror::ArtMethod* GetResolvedMethod(mirror::ArtMethod* outer_method,
+ uint32_t method_index,
+ InvokeType invoke_type)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ mirror::ArtMethod* caller = outer_method->GetDexCacheResolvedMethod(method_index);
+ if (!caller->IsRuntimeMethod()) {
+ return caller;
+ }
+
+ // The method in the dex cache can be the runtime method responsible for invoking
+ // the stub that will then update the dex cache. Therefore, we need to do the
+ // resolution ourselves.
+
+ StackHandleScope<3> hs(Thread::Current());
+ ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
+ Handle<mirror::ArtMethod> outer(hs.NewHandle(outer_method));
+ Handle<mirror::ClassLoader> class_loader(hs.NewHandle(outer->GetClassLoader()));
+ Handle<mirror::DexCache> dex_cache(hs.NewHandle(outer->GetDexCache()));
+ Handle<mirror::ArtMethod> referrer;
+ return class_linker->ResolveMethod(
+ *outer->GetDexFile(), method_index, dex_cache, class_loader, referrer, invoke_type);
+}
+
inline mirror::ArtMethod* GetCalleeSaveMethodCaller(StackReference<mirror::ArtMethod>* sp,
Runtime::CalleeSaveType type,
bool do_caller_check = false)
@@ -47,7 +70,25 @@
const size_t callee_frame_size = GetCalleeSaveFrameSize(kRuntimeISA, type);
auto* caller_sp = reinterpret_cast<StackReference<mirror::ArtMethod>*>(
reinterpret_cast<uintptr_t>(sp) + callee_frame_size);
- auto* caller = caller_sp->AsMirrorPtr();
+ mirror::ArtMethod* outer_method = caller_sp->AsMirrorPtr();
+ mirror::ArtMethod* caller = outer_method;
+
+ if ((outer_method != nullptr) && outer_method->IsOptimized(sizeof(void*))) {
+ const size_t callee_return_pc_offset = GetCalleeSaveReturnPcOffset(kRuntimeISA, type);
+ uintptr_t caller_pc = *reinterpret_cast<uintptr_t*>(
+ (reinterpret_cast<uint8_t*>(sp) + callee_return_pc_offset));
+ uintptr_t native_pc_offset = outer_method->NativeQuickPcOffset(caller_pc);
+ CodeInfo code_info = outer_method->GetOptimizedCodeInfo();
+ StackMap stack_map = code_info.GetStackMapForNativePcOffset(native_pc_offset);
+ DCHECK(stack_map.IsValid());
+ if (stack_map.HasInlineInfo(code_info)) {
+ InlineInfo inline_info = code_info.GetInlineInfoOf(stack_map);
+ uint32_t method_index = inline_info.GetMethodIndexAtDepth(inline_info.GetDepth() - 1);
+ InvokeType invoke_type = static_cast<InvokeType>(
+ inline_info.GetInvokeTypeAtDepth(inline_info.GetDepth() - 1));
+ caller = GetResolvedMethod(outer_method, method_index, invoke_type);
+ }
+ }
if (kIsDebugBuild && do_caller_check) {
// Note that do_caller_check is optional, as this method can be called by
diff --git a/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc b/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc
index c029eeb..33d7065 100644
--- a/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc
+++ b/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc
@@ -297,10 +297,37 @@
return GetCalleeSaveMethodCaller(sp, Runtime::kRefsAndArgs);
}
+ static mirror::ArtMethod* GetOuterMethod(StackReference<mirror::ArtMethod>* sp)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ DCHECK(sp->AsMirrorPtr()->IsCalleeSaveMethod());
+ uint8_t* previous_sp =
+ reinterpret_cast<uint8_t*>(sp) + kQuickCalleeSaveFrame_RefAndArgs_FrameSize;
+ return reinterpret_cast<StackReference<mirror::ArtMethod>*>(previous_sp)->AsMirrorPtr();
+ }
+
static uint32_t GetCallingDexPc(StackReference<mirror::ArtMethod>* sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
DCHECK(sp->AsMirrorPtr()->IsCalleeSaveMethod());
- return GetCallingMethod(sp)->ToDexPc(QuickArgumentVisitor::GetCallingPc(sp));
+ const size_t callee_frame_size = GetCalleeSaveFrameSize(kRuntimeISA, Runtime::kRefsAndArgs);
+ auto* caller_sp = reinterpret_cast<StackReference<mirror::ArtMethod>*>(
+ reinterpret_cast<uintptr_t>(sp) + callee_frame_size);
+ mirror::ArtMethod* outer_method = caller_sp->AsMirrorPtr();
+ uintptr_t outer_pc = QuickArgumentVisitor::GetCallingPc(sp);
+ uintptr_t outer_pc_offset = outer_method->NativeQuickPcOffset(outer_pc);
+
+ if (outer_method->IsOptimized(sizeof(void*))) {
+ CodeInfo code_info = outer_method->GetOptimizedCodeInfo();
+ StackMap stack_map = code_info.GetStackMapForNativePcOffset(outer_pc_offset);
+ DCHECK(stack_map.IsValid());
+ if (stack_map.HasInlineInfo(code_info)) {
+ InlineInfo inline_info = code_info.GetInlineInfoOf(stack_map);
+ return inline_info.GetDexPcAtDepth(inline_info.GetDepth() - 1);
+ } else {
+ return stack_map.GetDexPc(code_info);
+ }
+ } else {
+ return outer_method->ToDexPc(outer_pc);
+ }
}
// For the given quick ref and args quick frame, return the caller's PC.
@@ -2068,7 +2095,11 @@
StackReference<mirror::ArtMethod>* sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
ScopedQuickEntrypointChecks sqec(self);
- mirror::ArtMethod* caller_method = QuickArgumentVisitor::GetCallingMethod(sp);
+ // The optimizing compiler currently does not inline methods that have an interface
+ // invocation. We use the outer method directly to avoid fetching a stack map, which is
+ // more expensive.
+ mirror::ArtMethod* caller_method = QuickArgumentVisitor::GetOuterMethod(sp);
+ DCHECK_EQ(caller_method, QuickArgumentVisitor::GetCallingMethod(sp));
mirror::ArtMethod* interface_method = caller_method->GetDexCacheResolvedMethod(dex_method_idx);
mirror::ArtMethod* method;
if (LIKELY(interface_method->GetDexMethodIndex() != DexFile::kDexNoIndex)) {
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/native_bridge_art_interface.cc b/runtime/native_bridge_art_interface.cc
index b7f31f2..0ad560e 100644
--- a/runtime/native_bridge_art_interface.cc
+++ b/runtime/native_bridge_art_interface.cc
@@ -16,6 +16,8 @@
#include "native_bridge_art_interface.h"
+#include <signal.h>
+
#include "nativebridge/native_bridge.h"
#include "base/logging.h"
@@ -24,6 +26,7 @@
#include "mirror/art_method-inl.h"
#include "mirror/class-inl.h"
#include "scoped_thread_state_change.h"
+#include "sigchain.h"
namespace art {
@@ -127,7 +130,19 @@
}
void InitializeNativeBridge(JNIEnv* env, const char* instruction_set) {
- android::InitializeNativeBridge(env, instruction_set);
+ if (android::InitializeNativeBridge(env, instruction_set)) {
+ if (android::NativeBridgeGetVersion() >= 2U) {
+#ifdef _NSIG // Undefined on Apple, but we don't support running on Mac, anyways.
+ // Managed signal handling support added in version 2.
+ for (int signal = 0; signal < _NSIG; ++signal) {
+ android::NativeBridgeSignalHandlerFn fn = android::NativeBridgeGetSignalHandler(signal);
+ if (fn != nullptr) {
+ SetSpecialSignalHandlerFn(signal, fn);
+ }
+ }
+#endif
+ }
+ }
}
void UnloadNativeBridge() {
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/runtime/stack.cc b/runtime/stack.cc
index f7b96ea..09b56a1 100644
--- a/runtime/stack.cc
+++ b/runtime/stack.cc
@@ -18,6 +18,7 @@
#include "arch/context.h"
#include "base/hex_dump.h"
+#include "entrypoints/entrypoint_utils-inl.h"
#include "entrypoints/runtime_asm_entrypoints.h"
#include "gc_map.h"
#include "mirror/art_method-inl.h"
@@ -119,8 +120,11 @@
} else if (cur_quick_frame_ != nullptr) {
if (IsInInlinedFrame()) {
size_t depth_in_stack_map = current_inlining_depth_ - 1;
- return GetCurrentQuickFrame()->AsMirrorPtr()->GetDexCacheResolvedMethod(
- GetCurrentInlineInfo().GetMethodIndexAtDepth(depth_in_stack_map));
+ InlineInfo inline_info = GetCurrentInlineInfo();
+ uint32_t method_index = inline_info.GetMethodIndexAtDepth(depth_in_stack_map);
+ InvokeType invoke_type =
+ static_cast<InvokeType>(inline_info.GetInvokeTypeAtDepth(depth_in_stack_map));
+ return GetResolvedMethod(GetCurrentQuickFrame()->AsMirrorPtr(), method_index, invoke_type);
} else {
return cur_quick_frame_->AsMirrorPtr();
}
@@ -761,6 +765,7 @@
if (UNLIKELY(!should_continue)) {
return;
}
+ cur_depth_++;
}
}
}
diff --git a/sigchainlib/sigchain.cc b/sigchainlib/sigchain.cc
index 0359ed3..1391d14 100644
--- a/sigchainlib/sigchain.cc
+++ b/sigchainlib/sigchain.cc
@@ -39,7 +39,7 @@
class SignalAction {
public:
- SignalAction() : claimed_(false), uses_old_style_(false) {
+ SignalAction() : claimed_(false), uses_old_style_(false), special_handler_(nullptr) {
}
// Claim the signal and keep the action specified.
@@ -77,10 +77,19 @@
return uses_old_style_;
}
+ void SetSpecialHandler(SpecialSignalHandlerFn fn) {
+ special_handler_ = fn;
+ }
+
+ SpecialSignalHandlerFn GetSpecialHandler() {
+ return special_handler_;
+ }
+
private:
- struct sigaction action_; // Action to be performed.
- bool claimed_; // Whether signal is claimed or not.
- bool uses_old_style_; // Action is created using signal(). Use sa_handler.
+ struct sigaction action_; // Action to be performed.
+ bool claimed_; // Whether signal is claimed or not.
+ bool uses_old_style_; // Action is created using signal(). Use sa_handler.
+ SpecialSignalHandlerFn special_handler_; // A special handler executed before user handlers.
};
// User's signal handlers
@@ -109,9 +118,16 @@
}
}
+// Sigchainlib's own handler so we can ensure a managed handler is called first even if nobody
+// claimed a chain. Simply forward to InvokeUserSignalHandler.
+static void sigchainlib_managed_handler_sigaction(int sig, siginfo_t* info, void* context) {
+ InvokeUserSignalHandler(sig, info, context);
+}
+
// Claim a signal chain for a particular signal.
extern "C" void ClaimSignalChain(int signal, struct sigaction* oldaction) {
CheckSignalValid(signal);
+
user_sigactions[signal].Claim(*oldaction);
}
@@ -131,6 +147,15 @@
abort();
}
+ // Do we have a managed handler? If so, run it first.
+ SpecialSignalHandlerFn managed = user_sigactions[sig].GetSpecialHandler();
+ if (managed != nullptr) {
+ // Call the handler. If it succeeds, we're done.
+ if (managed(sig, info, context)) {
+ return;
+ }
+ }
+
const struct sigaction& action = user_sigactions[sig].GetAction();
if (user_sigactions[sig].OldStyle()) {
if (action.sa_handler != nullptr) {
@@ -303,5 +328,25 @@
initialized = true;
}
+extern "C" void SetSpecialSignalHandlerFn(int signal, SpecialSignalHandlerFn fn) {
+ CheckSignalValid(signal);
+
+ // Set the managed_handler.
+ user_sigactions[signal].SetSpecialHandler(fn);
+
+ // In case the chain isn't claimed, claim it for ourself so we can ensure the managed handler
+ // goes first.
+ if (!user_sigactions[signal].IsClaimed()) {
+ struct sigaction tmp;
+ tmp.sa_sigaction = sigchainlib_managed_handler_sigaction;
+ sigemptyset(&tmp.sa_mask);
+ tmp.sa_flags = SA_SIGINFO | SA_ONSTACK;
+#if !defined(__APPLE__) && !defined(__mips__)
+ tmp.sa_restorer = nullptr;
+#endif
+ user_sigactions[signal].Claim(tmp);
+ }
+}
+
} // namespace art
diff --git a/sigchainlib/sigchain.h b/sigchainlib/sigchain.h
index 79b76a7..01ccedf 100644
--- a/sigchainlib/sigchain.h
+++ b/sigchainlib/sigchain.h
@@ -27,6 +27,9 @@
extern "C" void UnclaimSignalChain(int signal);
+typedef bool (*SpecialSignalHandlerFn)(int, siginfo_t*, void*);
+extern "C" void SetSpecialSignalHandlerFn(int signal, SpecialSignalHandlerFn fn);
+
extern "C" void InvokeUserSignalHandler(int sig, siginfo_t* info, void* context);
extern "C" void EnsureFrontOfChain(int signal, struct sigaction* expected_action);
diff --git a/sigchainlib/sigchain_dummy.cc b/sigchainlib/sigchain_dummy.cc
index 70a4f71..8495a54 100644
--- a/sigchainlib/sigchain_dummy.cc
+++ b/sigchainlib/sigchain_dummy.cc
@@ -78,6 +78,12 @@
abort();
}
+extern "C" void SetSpecialSignalHandlerFn(int signal ATTRIBUTE_UNUSED,
+ SpecialSignalHandlerFn fn ATTRIBUTE_UNUSED) {
+ log("SetSpecialSignalHandlerFn is not exported by the main executable.");
+ abort();
+}
+
#pragma GCC diagnostic pop
} // namespace art
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/004-StackWalk/src/Main.java b/test/004-StackWalk/src/Main.java
index 1e2a91b..782f51d 100644
--- a/test/004-StackWalk/src/Main.java
+++ b/test/004-StackWalk/src/Main.java
@@ -2,9 +2,14 @@
public Main() {
}
- int f() {
+ int f() throws Exception {
g(1);
g(2);
+
+ // This loop currently defeats inlining of `f`.
+ for (int i = 0; i < 10; i++) {
+ Thread.sleep(0);
+ }
return 0;
}
@@ -86,7 +91,7 @@
System.loadLibrary("arttest");
}
- public static void main(String[] args) {
+ public static void main(String[] args) throws Exception {
Main st = new Main();
st.f();
}
diff --git a/test/004-StackWalk/stack_walk_jni.cc b/test/004-StackWalk/stack_walk_jni.cc
index c40de7e..97afe1c 100644
--- a/test/004-StackWalk/stack_walk_jni.cc
+++ b/test/004-StackWalk/stack_walk_jni.cc
@@ -45,11 +45,11 @@
if (m_name == "f") {
if (gJava_StackWalk_refmap_calls == 1) {
CHECK_EQ(1U, GetDexPc());
- CHECK_REGS(1);
+ CHECK_REGS(4);
} else {
CHECK_EQ(gJava_StackWalk_refmap_calls, 2);
CHECK_EQ(5U, GetDexPc());
- CHECK_REGS(1);
+ CHECK_REGS(4);
}
} else if (m_name == "g") {
if (gJava_StackWalk_refmap_calls == 1) {
diff --git a/test/115-native-bridge/expected.txt b/test/115-native-bridge/expected.txt
index deb70ba..464d2c8 100644
--- a/test/115-native-bridge/expected.txt
+++ b/test/115-native-bridge/expected.txt
@@ -4,7 +4,7 @@
Ready for native bridge tests.
Checking for support.
Getting trampoline for JNI_OnLoad with shorty (null).
-Test ART callbacks: all JNI function number is 10.
+Test ART callbacks: all JNI function number is 11.
name:booleanMethod, signature:(ZZZZZZZZZZ)Z, shorty:ZZZZZZZZZZZ.
name:byteMethod, signature:(BBBBBBBBBB)B, shorty:BBBBBBBBBBB.
name:charMethod, signature:(CCCCCCCCCC)C, shorty:CCCCCCCCCCC.
@@ -14,6 +14,7 @@
name:testFindFieldOnAttachedNativeThreadNative, signature:()V, shorty:V.
name:testGetMirandaMethodNative, signature:()Ljava/lang/reflect/Method;, shorty:L.
name:testNewStringObject, signature:()V, shorty:V.
+ name:testSignal, signature:()I, shorty:I.
name:testZeroLengthByteBuffers, signature:()V, shorty:V.
trampoline_JNI_OnLoad called!
Getting trampoline for Java_Main_testFindClassOnAttachedNativeThread with shorty V.
@@ -58,3 +59,5 @@
trampoline_Java_Main_charMethod called!
Getting trampoline for Java_Main_testNewStringObject with shorty V.
trampoline_Java_Main_testNewStringObject called!
+Getting trampoline for Java_Main_testSignal with shorty I.
+NB signal handler with signal 11.
diff --git a/test/115-native-bridge/nativebridge.cc b/test/115-native-bridge/nativebridge.cc
index db2fc9b..fd94b23 100644
--- a/test/115-native-bridge/nativebridge.cc
+++ b/test/115-native-bridge/nativebridge.cc
@@ -19,6 +19,8 @@
#include <algorithm>
#include <dlfcn.h>
#include <jni.h>
+#include <stdlib.h>
+#include <signal.h>
#include <vector>
#include "stdio.h"
@@ -179,6 +181,35 @@
return fnPtr(env, klass, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10);
}
+// This code is adapted from 004-SignalTest and causes a segfault.
+char *go_away_compiler = nullptr;
+
+[[ noreturn ]] static void test_sigaction_handler(int sig ATTRIBUTE_UNUSED,
+ siginfo_t* info ATTRIBUTE_UNUSED,
+ void* context ATTRIBUTE_UNUSED) {
+ printf("Should not reach the test sigaction handler.");
+ abort();
+}
+
+static jint trampoline_Java_Main_testSignal(JNIEnv*, jclass) {
+ // Install the sigaction handler above, which should *not* be reached as the native-bridge
+ // handler should be called first. Note: we won't chain at all, if we ever get here, we'll die.
+ struct sigaction tmp;
+ sigemptyset(&tmp.sa_mask);
+ tmp.sa_sigaction = test_sigaction_handler;
+ tmp.sa_restorer = nullptr;
+ sigaction(SIGSEGV, &tmp, nullptr);
+
+#if defined(__arm__) || defined(__i386__) || defined(__x86_64__) || defined(__aarch64__)
+ // On supported architectures we cause a real SEGV.
+ *go_away_compiler = 'a';
+#else
+ // On other architectures we simulate SEGV.
+ kill(getpid(), SIGSEGV);
+#endif
+ return 1234;
+}
+
NativeBridgeMethod gNativeBridgeMethods[] = {
{ "JNI_OnLoad", "", true, nullptr,
reinterpret_cast<void*>(trampoline_JNI_OnLoad) },
@@ -202,6 +233,8 @@
reinterpret_cast<void*>(trampoline_Java_Main_testNewStringObject) },
{ "testZeroLengthByteBuffers", "()V", true, nullptr,
reinterpret_cast<void*>(trampoline_Java_Main_testZeroLengthByteBuffers) },
+ { "testSignal", "()I", true, nullptr,
+ reinterpret_cast<void*>(trampoline_Java_Main_testSignal) },
};
static NativeBridgeMethod* find_native_bridge_method(const char *name) {
@@ -319,15 +352,73 @@
return &nb_env;
}
+// v2 parts.
+
+extern "C" bool nb_is_compatible(uint32_t bridge_version ATTRIBUTE_UNUSED) {
+ return true;
+}
+
+#if defined(__i386__) || defined(__x86_64__)
+#if defined(__APPLE__)
+#define ucontext __darwin_ucontext
+
+#if defined(__x86_64__)
+// 64 bit mac build.
+#define CTX_EIP uc_mcontext->__ss.__rip
+#else
+// 32 bit mac build.
+#define CTX_EIP uc_mcontext->__ss.__eip
+#endif
+
+#elif defined(__x86_64__)
+// 64 bit linux build.
+#define CTX_EIP uc_mcontext.gregs[REG_RIP]
+#else
+// 32 bit linux build.
+#define CTX_EIP uc_mcontext.gregs[REG_EIP]
+#endif
+#endif
+
+// A dummy special handler, continueing after the faulting location. This code comes from
+// 004-SignalTest.
+static bool nb_signalhandler(int sig, siginfo_t* info ATTRIBUTE_UNUSED, void* context) {
+ printf("NB signal handler with signal %d.\n", sig);
+#if defined(__arm__)
+ struct ucontext *uc = reinterpret_cast<struct ucontext*>(context);
+ struct sigcontext *sc = reinterpret_cast<struct sigcontext*>(&uc->uc_mcontext);
+ sc->arm_pc += 2; // Skip instruction causing segv.
+#elif defined(__aarch64__)
+ struct ucontext *uc = reinterpret_cast<struct ucontext*>(context);
+ struct sigcontext *sc = reinterpret_cast<struct sigcontext*>(&uc->uc_mcontext);
+ sc->pc += 4; // Skip instruction causing segv.
+#elif defined(__i386__) || defined(__x86_64__)
+ struct ucontext *uc = reinterpret_cast<struct ucontext*>(context);
+ uc->CTX_EIP += 3;
+#else
+ UNUSED(context);
+#endif
+ // We handled this...
+ return true;
+}
+
+static ::android::NativeBridgeSignalHandlerFn native_bridge_get_signal_handler(int signal) {
+ // Only test segfault handler.
+ if (signal == SIGSEGV) {
+ return &nb_signalhandler;
+ }
+ return nullptr;
+}
+
+
// "NativeBridgeItf" is effectively an API (it is the name of the symbol that will be loaded
// by the native bridge library).
android::NativeBridgeCallbacks NativeBridgeItf {
- .version = 1,
+ .version = 2,
.initialize = &native_bridge_initialize,
.loadLibrary = &native_bridge_loadLibrary,
.getTrampoline = &native_bridge_getTrampoline,
.isSupported = &native_bridge_isSupported,
.getAppEnv = &native_bridge_getAppEnv,
- .isCompatibleWith = nullptr,
- .getSignalHandler = nullptr
+ .isCompatibleWith = &nb_is_compatible,
+ .getSignalHandler = &native_bridge_get_signal_handler
};
diff --git a/test/115-native-bridge/src/NativeBridgeMain.java b/test/115-native-bridge/src/NativeBridgeMain.java
index c843707..25390f7 100644
--- a/test/115-native-bridge/src/NativeBridgeMain.java
+++ b/test/115-native-bridge/src/NativeBridgeMain.java
@@ -32,6 +32,7 @@
testCharMethod();
testEnvironment();
testNewStringObject();
+ testSignalHandler();
}
public static native void testFindClassOnAttachedNativeThread();
@@ -170,6 +171,18 @@
}
private static native void testNewStringObject();
+
+ // Test v2 special signal handlers. This uses the native code from 004-SignalTest to cause
+ // a non-managed segfault.
+ private static void testSignalHandler() {
+ // This uses code from 004-SignalTest.
+ int x = testSignal();
+ if (x != 1234) {
+ throw new AssertionError();
+ }
+ }
+
+ private static native int testSignal();
}
public class NativeBridgeMain {
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..9bf7cdf 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++) {
@@ -340,6 +340,30 @@
}
}
+ public SubclassA a = new SubclassA();
+ public static SubclassA b = new SubclassA();
+
+ /// CHECK-START: void Main.testInstanceFieldGetSimpleRemove() instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
+
+ /// CHECK-START: void Main.testInstanceFieldGetSimpleRemove() instruction_simplifier_after_types (after)
+ /// CHECK-NOT: CheckCast
+ public void testInstanceFieldGetSimpleRemove() {
+ Main m = new Main();
+ Super a = m.a;
+ ((SubclassA)a).g();
+ }
+
+ /// CHECK-START: void Main.testStaticFieldGetSimpleRemove() instruction_simplifier_after_types (before)
+ /// CHECK: CheckCast
+
+ /// CHECK-START: void Main.testStaticFieldGetSimpleRemove() instruction_simplifier_after_types (after)
+ /// CHECK-NOT: CheckCast
+ public void testStaticFieldGetSimpleRemove() {
+ Super b = Main.b;
+ ((SubclassA)b).g();
+ }
+
public static void main(String[] args) {
}
}
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/466-get-live-vreg/src/Main.java b/test/466-get-live-vreg/src/Main.java
index 3118085..851506b 100644
--- a/test/466-get-live-vreg/src/Main.java
+++ b/test/466-get-live-vreg/src/Main.java
@@ -53,18 +53,30 @@
}
public static void main(String[] args) {
- if (testLiveArgument(42) != 42) {
- throw new Error("Expected 42");
+ if (testLiveArgument(staticField3) != staticField3) {
+ throw new Error("Expected " + staticField3);
}
- if (testLiveArgument(42) != 42) {
- throw new Error("Expected 42");
+ if (testLiveArgument(staticField3) != staticField3) {
+ throw new Error("Expected " + staticField3);
}
- testIntervalHole(1, true);
- testIntervalHole(1, false);
+ testWrapperIntervalHole(1, true);
+ testWrapperIntervalHole(1, false);
+ }
+
+ // Wrapper method to avoid inlining, which affects liveness
+ // of dex registers.
+ static void testWrapperIntervalHole(int arg, boolean test) {
+ try {
+ Thread.sleep(0);
+ testIntervalHole(arg, test);
+ } catch (Exception e) {
+ throw new Error(e);
+ }
}
static int staticField1;
static int staticField2;
+ static int staticField3 = 42;
}
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..51be912 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,25 +149,25 @@
* 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() {
// The invocation of invokeStaticNotInlined triggers the
// initialization of ClassWithClinit4, meaning that the
- // hereinbelow call to staticMethod does not need a clinit
+ // call to staticMethod below does not need a clinit
// check.
staticMethod();
}
@@ -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/test/487-checker-inline-calls/expected.txt b/test/487-checker-inline-calls/expected.txt
new file mode 100644
index 0000000..2230482
--- /dev/null
+++ b/test/487-checker-inline-calls/expected.txt
@@ -0,0 +1,6 @@
+java.lang.Error
+ at Main.inline3(Main.java:48)
+ at Main.inline2(Main.java:44)
+ at Main.inline1(Main.java:40)
+ at Main.doTopCall(Main.java:36)
+ at Main.main(Main.java:21)
diff --git a/test/487-checker-inline-calls/info.txt b/test/487-checker-inline-calls/info.txt
new file mode 100644
index 0000000..9f5df8b
--- /dev/null
+++ b/test/487-checker-inline-calls/info.txt
@@ -0,0 +1 @@
+Checker test for ensuring inlining preserves stack traces.
diff --git a/test/487-checker-inline-calls/src/Main.java b/test/487-checker-inline-calls/src/Main.java
new file mode 100644
index 0000000..70384d5
--- /dev/null
+++ b/test/487-checker-inline-calls/src/Main.java
@@ -0,0 +1,50 @@
+/*
+ * 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.
+ */
+
+
+public class Main {
+ public static void main(String[] args) {
+ try {
+ doTopCall();
+ } catch (Error e) {
+ e.printStackTrace();
+ }
+ }
+
+ // We check that some inlining happened by checking the
+ // method index of the called method.
+
+ /// CHECK-START: void Main.doTopCall() inliner (before)
+ /// CHECK: InvokeStaticOrDirect dex_file_index:2
+
+ /// CHECK-START: void Main.doTopCall() inliner (after)
+ /// CHECK: InvokeStaticOrDirect dex_file_index:4
+ public static void doTopCall() {
+ inline1();
+ }
+
+ public static void inline1() {
+ inline2();
+ }
+
+ public static void inline2() {
+ inline3();
+ }
+
+ public static void inline3() {
+ throw new Error();
+ }
+}
diff --git a/test/488-checker-inline-recursive-calls/expected.txt b/test/488-checker-inline-recursive-calls/expected.txt
new file mode 100644
index 0000000..f615d3a
--- /dev/null
+++ b/test/488-checker-inline-recursive-calls/expected.txt
@@ -0,0 +1,7 @@
+java.lang.Error
+ at Main.inline3(Main.java:51)
+ at Main.doTopCall(Main.java:37)
+ at Main.inline2(Main.java:47)
+ at Main.inline1(Main.java:43)
+ at Main.doTopCall(Main.java:34)
+ at Main.main(Main.java:21)
diff --git a/test/488-checker-inline-recursive-calls/info.txt b/test/488-checker-inline-recursive-calls/info.txt
new file mode 100644
index 0000000..9abd93c
--- /dev/null
+++ b/test/488-checker-inline-recursive-calls/info.txt
@@ -0,0 +1 @@
+Checker test for inlining calls that in turn call the outer method.
diff --git a/test/488-checker-inline-recursive-calls/src/Main.java b/test/488-checker-inline-recursive-calls/src/Main.java
new file mode 100644
index 0000000..c1f25b3
--- /dev/null
+++ b/test/488-checker-inline-recursive-calls/src/Main.java
@@ -0,0 +1,53 @@
+/*
+ * 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.
+ */
+
+
+public class Main {
+ public static void main(String[] args) {
+ try {
+ doTopCall(true);
+ } catch (Error e) {
+ e.printStackTrace();
+ }
+ }
+
+ /// CHECK-START: void Main.doTopCall(boolean) inliner (before)
+ /// CHECK-NOT: InvokeStaticOrDirect recursive:true
+
+ /// CHECK-START: void Main.doTopCall(boolean) inliner (after)
+ /// CHECK: InvokeStaticOrDirect recursive:true
+ public static void doTopCall(boolean first_call) {
+ if (first_call) {
+ inline1();
+ } else {
+ while (true) {
+ inline3();
+ }
+ }
+ }
+
+ public static void inline1() {
+ inline2();
+ }
+
+ public static void inline2() {
+ doTopCall(false);
+ }
+
+ public static void inline3() {
+ throw new Error();
+ }
+}
diff --git a/test/Android.run-test.mk b/test/Android.run-test.mk
index 8b074ae..d224f43 100644
--- a/test/Android.run-test.mk
+++ b/test/Android.run-test.mk
@@ -32,11 +32,14 @@
# an empty file touched in the intermediate directory.
TEST_ART_RUN_TEST_BUILD_RULES :=
+# Dependencies for actually running a run-test.
+TEST_ART_RUN_TEST_DEPENDENCIES := $(DX) $(HOST_OUT_EXECUTABLES)/jasmin $(HOST_OUT_EXECUTABLES)/smali $(HOST_OUT_EXECUTABLES)/dexmerger
+
# Helper to create individual build targets for tests. Must be called with $(eval).
# $(1): the test number
define define-build-art-run-test
dmart_target := $(art_run_tests_dir)/art-run-tests/$(1)/touch
-$$(dmart_target): $(DX) $(HOST_OUT_EXECUTABLES)/jasmin $(HOST_OUT_EXECUTABLES)/smali $(HOST_OUT_EXECUTABLES)/dexmerger
+$$(dmart_target): $(TEST_ART_RUN_TEST_DEPENDENCIES)
$(hide) rm -rf $$(dir $$@) && mkdir -p $$(dir $$@)
$(hide) DX=$(abspath $(DX)) JASMIN=$(abspath $(HOST_OUT_EXECUTABLES)/jasmin) \
SMALI=$(abspath $(HOST_OUT_EXECUTABLES)/smali) \
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"
]
},
{