Inlining setters that return one of their arguments.
Useful for builder classes and synthetic setters. The latter
are not inlined yet since they are static methods, i.e. they
don't use "this" as the object for IPUT.
Change-Id: I3d34156c3629b837a0a95ccc34a8aae3f4a636d5
diff --git a/compiler/dex/quick/dex_file_method_inliner.cc b/compiler/dex/quick/dex_file_method_inliner.cc
index 80a88b8..3eaaea1 100644
--- a/compiler/dex/quick/dex_file_method_inliner.cc
+++ b/compiler/dex/quick/dex_file_method_inliner.cc
@@ -412,7 +412,8 @@
result = GenInlineIGet(mir_graph, bb, invoke, move_result, method, method_idx);
break;
case kInlineOpIPut:
- result = GenInlineIPut(mir_graph, bb, invoke, method, method_idx);
+ move_result = mir_graph->FindMoveResult(bb, invoke);
+ result = GenInlineIPut(mir_graph, bb, invoke, move_result, method, method_idx);
break;
default:
LOG(FATAL) << "Unexpected inline op: " << method.opcode;
@@ -672,7 +673,8 @@
}
bool DexFileMethodInliner::GenInlineIPut(MIRGraph* mir_graph, BasicBlock* bb, MIR* invoke,
- const InlineMethod& method, uint32_t method_idx) {
+ MIR* move_result, const InlineMethod& method,
+ uint32_t method_idx) {
CompilationUnit* cu = mir_graph->GetCurrentDexCompilationUnit()->GetCompilationUnit();
if (cu->enable_debug & (1 << kDebugSlowFieldPath)) {
return false;
@@ -683,12 +685,21 @@
DCHECK_EQ(InlineMethodAnalyser::IPutVariant(opcode), data.op_variant);
uint32_t object_reg = GetInvokeReg(invoke, data.object_arg);
uint32_t src_reg = GetInvokeReg(invoke, data.src_arg);
+ uint32_t return_reg =
+ data.return_arg_plus1 != 0u ? GetInvokeReg(invoke, data.return_arg_plus1 - 1u) : 0u;
if (opcode == Instruction::IPUT_WIDE && !WideArgIsInConsecutiveDalvikRegs(invoke, data.src_arg)) {
// The two halfs of the source value are not in consecutive dalvik registers in INVOKE.
return false;
}
+ DCHECK(move_result == nullptr || data.return_arg_plus1 != 0u);
+ if (move_result != nullptr && move_result->dalvikInsn.opcode == Instruction::MOVE_RESULT_WIDE &&
+ !WideArgIsInConsecutiveDalvikRegs(invoke, data.return_arg_plus1 - 1u)) {
+ // The two halfs of the return value are not in consecutive dalvik registers in INVOKE.
+ return false;
+ }
+
DCHECK_EQ(data.method_is_static != 0u,
invoke->dalvikInsn.opcode == Instruction::INVOKE_STATIC ||
invoke->dalvikInsn.opcode == Instruction::INVOKE_STATIC_RANGE);
@@ -703,7 +714,7 @@
invoke->dalvikInsn.opcode = static_cast<Instruction::Code>(kMirOpNop);
}
- MIR* insn = AllocReplacementMIR(mir_graph, invoke, nullptr);
+ MIR* insn = AllocReplacementMIR(mir_graph, invoke, move_result);
insn->dalvikInsn.opcode = opcode;
insn->dalvikInsn.vA = src_reg;
insn->dalvikInsn.vB = object_reg;
@@ -715,6 +726,24 @@
DCHECK_EQ(data.is_volatile, mir_graph->GetIFieldLoweringInfo(insn).IsVolatile() ? 1u : 0u);
bb->InsertMIRAfter(invoke, insn);
+
+ if (move_result != nullptr) {
+ MIR* move = AllocReplacementMIR(mir_graph, invoke, move_result);
+ insn->width = invoke->width;
+ move->offset = move_result->offset;
+ move->width = move_result->width;
+ if (move_result->dalvikInsn.opcode == Instruction::MOVE_RESULT) {
+ move->dalvikInsn.opcode = Instruction::MOVE_FROM16;
+ } else if (move_result->dalvikInsn.opcode == Instruction::MOVE_RESULT_OBJECT) {
+ move->dalvikInsn.opcode = Instruction::MOVE_OBJECT_FROM16;
+ } else {
+ DCHECK_EQ(move_result->dalvikInsn.opcode, Instruction::MOVE_RESULT_WIDE);
+ move->dalvikInsn.opcode = Instruction::MOVE_WIDE_FROM16;
+ }
+ move->dalvikInsn.vA = move_result->dalvikInsn.vA;
+ move->dalvikInsn.vB = return_reg;
+ bb->InsertMIRAfter(insn, move);
+ }
return true;
}
diff --git a/compiler/dex/quick/dex_file_method_inliner.h b/compiler/dex/quick/dex_file_method_inliner.h
index b4e190a..c03f89c 100644
--- a/compiler/dex/quick/dex_file_method_inliner.h
+++ b/compiler/dex/quick/dex_file_method_inliner.h
@@ -302,7 +302,7 @@
static bool GenInlineIGet(MIRGraph* mir_graph, BasicBlock* bb, MIR* invoke,
MIR* move_result, const InlineMethod& method, uint32_t method_idx);
static bool GenInlineIPut(MIRGraph* mir_graph, BasicBlock* bb, MIR* invoke,
- const InlineMethod& method, uint32_t method_idx);
+ MIR* move_result, const InlineMethod& method, uint32_t method_idx);
ReaderWriterMutex lock_;
/*
diff --git a/compiler/dex/quick/mir_to_lir.cc b/compiler/dex/quick/mir_to_lir.cc
index 73fdc82..6fcdf70 100644
--- a/compiler/dex/quick/mir_to_lir.cc
+++ b/compiler/dex/quick/mir_to_lir.cc
@@ -120,7 +120,7 @@
bool Mir2Lir::GenSpecialIGet(MIR* mir, const InlineMethod& special) {
// FastInstance() already checked by DexFileMethodInliner.
const InlineIGetIPutData& data = special.d.ifield_data;
- if (data.method_is_static || data.object_arg != 0) {
+ if (data.method_is_static != 0u || data.object_arg != 0u) {
// The object is not "this" and has to be null-checked.
return false;
}
@@ -151,10 +151,14 @@
bool Mir2Lir::GenSpecialIPut(MIR* mir, const InlineMethod& special) {
// FastInstance() already checked by DexFileMethodInliner.
const InlineIGetIPutData& data = special.d.ifield_data;
- if (data.method_is_static || data.object_arg != 0) {
+ if (data.method_is_static != 0u || data.object_arg != 0u) {
// The object is not "this" and has to be null-checked.
return false;
}
+ if (data.return_arg_plus1 != 0u) {
+ // The setter returns a method argument which we don't support here.
+ return false;
+ }
bool wide = (data.op_variant == InlineMethodAnalyser::IPutVariant(Instruction::IPUT_WIDE));
diff --git a/runtime/quick/inline_method_analyser.cc b/runtime/quick/inline_method_analyser.cc
index a9072d8..0a1b72e 100644
--- a/runtime/quick/inline_method_analyser.cc
+++ b/runtime/quick/inline_method_analyser.cc
@@ -218,16 +218,24 @@
uint32_t arg_start = code_item->registers_size_ - code_item->ins_size_;
DCHECK_GE(object_reg, arg_start);
DCHECK_LT(object_reg, code_item->registers_size_);
+ uint32_t object_arg = object_reg - arg_start;
+
DCHECK_LT(opcode == Instruction::IGET_WIDE ? dst_reg + 1 : dst_reg, code_item->registers_size_);
if (dst_reg != return_reg) {
return false; // Not returning the value retrieved by IGET?
}
- if ((verifier->GetAccessFlags() & kAccStatic) != 0 || object_reg != arg_start) {
+ if ((verifier->GetAccessFlags() & kAccStatic) != 0u || object_arg != 0u) {
// TODO: Support inlining IGET on other register than "this".
return false;
}
+ // InlineIGetIPutData::object_arg is only 4 bits wide.
+ static constexpr uint16_t kMaxObjectArg = 15u;
+ if (object_arg > kMaxObjectArg) {
+ return false;
+ }
+
if (result != nullptr) {
InlineIGetIPutData* data = &result->d.ifield_data;
if (!ComputeSpecialAccessorInfo(field_idx, false, verifier, data)) {
@@ -236,10 +244,10 @@
result->opcode = kInlineOpIGet;
result->flags = kInlineSpecial;
data->op_variant = IGetVariant(opcode);
- data->object_arg = object_reg - arg_start; // Allow IGET on any register, not just "this".
+ data->method_is_static = (verifier->GetAccessFlags() & kAccStatic) != 0 ? 1u : 0u;
+ data->object_arg = object_arg; // Allow IGET on any register, not just "this".
data->src_arg = 0;
- data->method_is_static = (verifier->GetAccessFlags() & kAccStatic) != 0;
- data->reserved = 0;
+ data->return_arg_plus1 = 0u;
}
return true;
}
@@ -253,29 +261,45 @@
const Instruction* return_instruction = instruction->Next();
Instruction::Code return_opcode = return_instruction->Opcode();
+ uint32_t arg_start = code_item->registers_size_ - code_item->ins_size_;
+ uint16_t return_arg_plus1 = 0u;
if (return_opcode != Instruction::RETURN_VOID) {
- // TODO: Support returning an argument.
- // This is needed by builder classes and generated accessor setters.
- // builder.setX(value): iput value, this, fieldX; return-object this;
- // object.access$nnn(value): iput value, this, fieldX; return value;
- // Use InlineIGetIPutData::reserved to hold the information.
- return false;
+ if (return_opcode != Instruction::RETURN &&
+ return_opcode != Instruction::RETURN_OBJECT &&
+ return_opcode != Instruction::RETURN_WIDE) {
+ return false;
+ }
+ // Returning an argument.
+ uint32_t return_reg = return_instruction->VRegA_11x();
+ DCHECK_GE(return_reg, arg_start);
+ DCHECK_LT(return_opcode == Instruction::RETURN_WIDE ? return_reg + 1u : return_reg,
+ code_item->registers_size_);
+ return_arg_plus1 = return_reg - arg_start + 1u;
}
uint32_t src_reg = instruction->VRegA_22c();
uint32_t object_reg = instruction->VRegB_22c();
uint32_t field_idx = instruction->VRegC_22c();
- uint32_t arg_start = code_item->registers_size_ - code_item->ins_size_;
DCHECK_GE(object_reg, arg_start);
DCHECK_LT(object_reg, code_item->registers_size_);
DCHECK_GE(src_reg, arg_start);
DCHECK_LT(opcode == Instruction::IPUT_WIDE ? src_reg + 1 : src_reg, code_item->registers_size_);
+ uint32_t object_arg = object_reg - arg_start;
+ uint32_t src_arg = src_reg - arg_start;
- if ((verifier->GetAccessFlags() & kAccStatic) != 0 || object_reg != arg_start) {
+ if ((verifier->GetAccessFlags() & kAccStatic) != 0 || object_arg != 0) {
// TODO: Support inlining IPUT on other register than "this".
return false;
}
+ // InlineIGetIPutData::object_arg/src_arg/return_arg_plus1 are each only 4 bits wide.
+ static constexpr uint16_t kMaxObjectArg = 15u;
+ static constexpr uint16_t kMaxSrcArg = 15u;
+ static constexpr uint16_t kMaxReturnArgPlus1 = 15u;
+ if (object_arg > kMaxObjectArg || src_arg > kMaxSrcArg || return_arg_plus1 > kMaxReturnArgPlus1) {
+ return false;
+ }
+
if (result != nullptr) {
InlineIGetIPutData* data = &result->d.ifield_data;
if (!ComputeSpecialAccessorInfo(field_idx, true, verifier, data)) {
@@ -284,10 +308,10 @@
result->opcode = kInlineOpIPut;
result->flags = kInlineSpecial;
data->op_variant = IPutVariant(opcode);
- data->object_arg = object_reg - arg_start; // Allow IPUT on any register, not just "this".
- data->src_arg = src_reg - arg_start;
- data->method_is_static = (verifier->GetAccessFlags() & kAccStatic) != 0;
- data->reserved = 0;
+ data->method_is_static = (verifier->GetAccessFlags() & kAccStatic) != 0 ? 1u : 0u;
+ data->object_arg = object_arg; // Allow IPUT on any register, not just "this".
+ data->src_arg = src_arg;
+ data->return_arg_plus1 = return_arg_plus1;
}
return true;
}
diff --git a/runtime/quick/inline_method_analyser.h b/runtime/quick/inline_method_analyser.h
index 8e1a408..277a01e 100644
--- a/runtime/quick/inline_method_analyser.h
+++ b/runtime/quick/inline_method_analyser.h
@@ -98,10 +98,10 @@
// opcode-Instruction::IPUT for IPUTs. This is because the runtime
// doesn't know the OpSize enumeration.
uint16_t op_variant : 3;
+ uint16_t method_is_static : 1;
uint16_t object_arg : 4;
uint16_t src_arg : 4; // iput only
- uint16_t method_is_static : 1;
- uint16_t reserved : 4;
+ uint16_t return_arg_plus1 : 4; // iput only, method argument to return + 1, 0 = return void.
uint16_t field_idx;
uint32_t is_volatile : 1;
uint32_t field_offset : 31;
diff --git a/test/083-compiler-regressions/expected.txt b/test/083-compiler-regressions/expected.txt
index c1e30bc..db50300 100644
--- a/test/083-compiler-regressions/expected.txt
+++ b/test/083-compiler-regressions/expected.txt
@@ -21,6 +21,10 @@
wideGetterSetterTest passes
wideIdentityTest passes
returnConstantTest passes
+setterTestWithReturnArgIgnoreReturn passes
+setterTestWithReturnArgUseReturn passes
+wideSetterTestWithReturnArgIgnoreReturn passes
+wideSetterTestWithReturnArgUseReturn passes
LVNTests.testNPE1 passes
LVNTests.testNPE2 passes
longDivTest passes
diff --git a/test/083-compiler-regressions/src/Main.java b/test/083-compiler-regressions/src/Main.java
index 586ff87..d32c037 100644
--- a/test/083-compiler-regressions/src/Main.java
+++ b/test/083-compiler-regressions/src/Main.java
@@ -43,6 +43,10 @@
wideGetterSetterTest();
wideIdentityTest();
returnConstantTest();
+ setterTestWithReturnArgIgnoreReturn();
+ setterTestWithReturnArgUseReturn();
+ wideSetterTestWithReturnArgIgnoreReturn();
+ wideSetterTestWithReturnArgUseReturn();
LVNTests.testNPE1();
LVNTests.testNPE2();
ZeroTests.longDivTest();
@@ -179,6 +183,576 @@
}
}
+ static void setterTestWithReturnArgIgnoreReturn() {
+ Foo foo = new Foo();
+ int sum = foo.getBar0();
+ sum += foo.getBar0();
+ foo.setBar1ReturnThis(sum);
+ sum += foo.getBar0();
+ foo.setBar2ReturnThis(1,sum);
+ sum += foo.getBar0();
+ foo.setBar3ReturnThis(1,2,sum);
+ sum += foo.getBar0();
+ foo.setBar4ReturnThis(1,2,3,sum);
+ sum += foo.getBar0();
+ foo.setBar5ReturnThis(1,2,3,4,sum);
+ sum += foo.getBar0();
+ foo.setBar1ReturnBarArg(sum);
+ sum += foo.getBar0();
+ foo.setBar2ReturnBarArg(1,sum);
+ sum += foo.getBar0();
+ foo.setBar3ReturnBarArg(1,2,sum);
+ sum += foo.getBar0();
+ foo.setBar4ReturnBarArg(1,2,3,sum);
+ sum += foo.getBar0();
+ foo.setBar5ReturnBarArg(1,2,3,4,sum);
+ sum += foo.getBar0();
+ foo.setBar2ReturnDummyArg1(1,sum);
+ sum += foo.getBar0();
+ foo.setBar3ReturnDummyArg2(1,2,sum);
+ sum += foo.getBar0();
+ foo.setBar4ReturnDummyArg3(1,2,3,sum);
+ sum += foo.getBar0();
+ foo.setBar5ReturnDummyArg4(1,2,3,4,sum);
+ sum += foo.getBar0();
+ Foo nullFoo = Foo.getNullFoo();
+ try {
+ nullFoo.setBar1ReturnThis(sum);
+ } catch(NullPointerException npe) {
+ sum += 404;
+ }
+ try {
+ nullFoo.setBar2ReturnThis(1, sum);
+ } catch(NullPointerException npe) {
+ sum += 2 * 404;
+ }
+ try {
+ nullFoo.setBar3ReturnThis(1, 2, sum);
+ } catch(NullPointerException npe) {
+ sum += 3 * 404;
+ }
+ try {
+ nullFoo.setBar4ReturnThis(1, 2, 3, sum);
+ } catch(NullPointerException npe) {
+ sum += 4 * 404;
+ }
+ try {
+ nullFoo.setBar5ReturnThis(1, 2, 3, 4, sum);
+ } catch(NullPointerException npe) {
+ sum += 5 * 404;
+ }
+ try {
+ nullFoo.setBar1ReturnBarArg(sum);
+ } catch(NullPointerException npe) {
+ sum += 6 * 404;
+ }
+ try {
+ nullFoo.setBar2ReturnBarArg(1, sum);
+ } catch(NullPointerException npe) {
+ sum += 7 * 404;
+ }
+ try {
+ nullFoo.setBar3ReturnBarArg(1, 2, sum);
+ } catch(NullPointerException npe) {
+ sum += 8 * 404;
+ }
+ try {
+ nullFoo.setBar4ReturnBarArg(1, 2, 3, sum);
+ } catch(NullPointerException npe) {
+ sum += 9 * 404;
+ }
+ try {
+ nullFoo.setBar5ReturnBarArg(1, 2, 3, 4, sum);
+ } catch(NullPointerException npe) {
+ sum += 10 * 404;
+ }
+ try {
+ nullFoo.setBar2ReturnDummyArg1(1, sum);
+ } catch(NullPointerException npe) {
+ sum += 11 * 404;
+ }
+ try {
+ nullFoo.setBar3ReturnDummyArg2(1, 2, sum);
+ } catch(NullPointerException npe) {
+ sum += 12 * 404;
+ }
+ try {
+ nullFoo.setBar4ReturnDummyArg3(1, 2, 3, sum);
+ } catch(NullPointerException npe) {
+ sum += 13 * 404;
+ }
+ try {
+ nullFoo.setBar5ReturnDummyArg4(1, 2, 3, 4, sum);
+ } catch(NullPointerException npe) {
+ sum += 14 * 404;
+ }
+ int expected = (1234 << 15) + 404 * (15 * 14 / 2);
+ if (sum == expected) {
+ System.out.println("setterTestWithReturnArgIgnoreReturn passes");
+ }
+ else {
+ System.out.println("setterTestWithReturnArgIgnoreReturn fails: " + sum +
+ " (expecting " + expected + ")");
+ }
+ }
+
+ static void setterTestWithReturnArgUseReturn() {
+ Foo foo = new Foo();
+ int sum = foo.getBar0();
+ int sumDummy = 0;
+ sum += foo.getBar0();
+ Foo foo2 = foo.setBar1ReturnThis(sum);
+ sum += foo2.getBar0();
+ foo = foo2.setBar2ReturnThis(1,sum);
+ sum += foo.getBar0();
+ foo2 = foo.setBar3ReturnThis(1,2,sum);
+ sum += foo2.getBar0();
+ foo = foo2.setBar4ReturnThis(1,2,3,sum);
+ sum += foo.getBar0();
+ foo = foo.setBar5ReturnThis(1,2,3,4,sum);
+ sum += foo.getBar0();
+ sum += foo.setBar1ReturnBarArg(sum);
+ sum += foo.getBar0();
+ sum += foo.setBar2ReturnBarArg(1,sum);
+ sum += foo.getBar0();
+ sum += foo.setBar3ReturnBarArg(1,2,sum);
+ sum += foo.getBar0();
+ sum += foo.setBar4ReturnBarArg(1,2,3,sum);
+ sum += foo.getBar0();
+ sum += foo.setBar5ReturnBarArg(1,2,3,4,sum);
+ sum += foo.getBar0();
+ sumDummy += foo.setBar2ReturnDummyArg1(1,sum);
+ sum += foo.getBar0();
+ sumDummy += foo.setBar3ReturnDummyArg2(1,2,sum);
+ sum += foo.getBar0();
+ sumDummy += foo.setBar4ReturnDummyArg3(1,2,3,sum);
+ sum += foo.getBar0();
+ sumDummy += foo.setBar5ReturnDummyArg4(1,2,3,4,sum);
+ sum += foo.getBar0();
+ Foo nullFoo = Foo.getNullFoo();
+ try {
+ foo = nullFoo.setBar1ReturnThis(sum);
+ } catch(NullPointerException npe) {
+ sum += 404;
+ }
+ try {
+ foo = nullFoo.setBar2ReturnThis(1, sum);
+ } catch(NullPointerException npe) {
+ sum += 2 * 404;
+ }
+ try {
+ foo = nullFoo.setBar3ReturnThis(1, 2, sum);
+ } catch(NullPointerException npe) {
+ sum += 3 * 404;
+ }
+ try {
+ foo = nullFoo.setBar4ReturnThis(1, 2, 3, sum);
+ } catch(NullPointerException npe) {
+ sum += 4 * 404;
+ }
+ try {
+ foo = nullFoo.setBar5ReturnThis(1, 2, 3, 4, sum);
+ } catch(NullPointerException npe) {
+ sum += 5 * 404;
+ }
+ try {
+ sum += nullFoo.setBar1ReturnBarArg(sum);
+ } catch(NullPointerException npe) {
+ sum += 6 * 404;
+ }
+ try {
+ sum += nullFoo.setBar2ReturnBarArg(1, sum);
+ } catch(NullPointerException npe) {
+ sum += 7 * 404;
+ }
+ try {
+ sum += nullFoo.setBar3ReturnBarArg(1, 2, sum);
+ } catch(NullPointerException npe) {
+ sum += 8 * 404;
+ }
+ try {
+ sum += nullFoo.setBar4ReturnBarArg(1, 2, 3, sum);
+ } catch(NullPointerException npe) {
+ sum += 9 * 404;
+ }
+ try {
+ sum += nullFoo.setBar5ReturnBarArg(1, 2, 3, 4, sum);
+ } catch(NullPointerException npe) {
+ sum += 10 * 404;
+ }
+ try {
+ sumDummy += nullFoo.setBar2ReturnDummyArg1(1, sum);
+ } catch(NullPointerException npe) {
+ sum += 11 * 404;
+ }
+ try {
+ sumDummy += nullFoo.setBar3ReturnDummyArg2(1, 2, sum);
+ } catch(NullPointerException npe) {
+ sum += 12 * 404;
+ }
+ try {
+ sumDummy += nullFoo.setBar4ReturnDummyArg3(1, 2, 3, sum);
+ } catch(NullPointerException npe) {
+ sum += 13 * 404;
+ }
+ try {
+ sumDummy += nullFoo.setBar5ReturnDummyArg4(1, 2, 3, 4, sum);
+ } catch(NullPointerException npe) {
+ sum += 14 * 404;
+ }
+ int expected = (1234 << 10) * 3 * 3 * 3 * 3 * 3 + 404 * (15 * 14 / 2);
+ int expectedDummy = 5 * 4 / 2;
+ if (sum == expected && sumDummy == expectedDummy) {
+ System.out.println("setterTestWithReturnArgUseReturn passes");
+ }
+ else {
+ System.out.println("setterTestWithReturnArgUseReturn fails: " + sum +
+ " (expecting " + expected + "), sumDummy = " + sumDummy +
+ "(expecting " + expectedDummy + ")");
+ }
+ }
+
+ static void wideSetterTestWithReturnArgIgnoreReturn() {
+ Foo foo = new Foo();
+ long sum = foo.wideGetBar0();
+ sum += foo.wideGetBar0();
+ foo.wideSetBar1ReturnThis(sum);
+ sum += foo.wideGetBar0();
+ foo.wideSetBar2ReturnThis(1,sum);
+ sum += foo.wideGetBar0();
+ foo.wideSetBar3ReturnThis(1,2,sum);
+ sum += foo.wideGetBar0();
+ foo.wideSetBar4ReturnThis(1,2,3,sum);
+ sum += foo.wideGetBar0();
+ foo.wideSetBar5ReturnThis(1,2,3,4,sum);
+ sum += foo.wideGetBar0();
+ foo.wideSetBar1ReturnBarArg(sum);
+ sum += foo.wideGetBar0();
+ foo.wideSetBar2ReturnBarArg(1,sum);
+ sum += foo.wideGetBar0();
+ foo.wideSetBar3ReturnBarArg(1,2,sum);
+ sum += foo.wideGetBar0();
+ foo.wideSetBar4ReturnBarArg(1,2,3,sum);
+ sum += foo.wideGetBar0();
+ foo.wideSetBar5ReturnBarArg(1,2,3,4,sum);
+ sum += foo.wideGetBar0();
+ foo.wideSetBar2iReturnBarArg(1,sum);
+ sum += foo.wideGetBar0();
+ foo.wideSetBar3iReturnBarArg(1,2,sum);
+ sum += foo.wideGetBar0();
+ foo.wideSetBar4iReturnBarArg(1,2,3,sum);
+ sum += foo.wideGetBar0();
+ foo.wideSetBar5iReturnBarArg(1,2,3,4,sum);
+ sum += foo.wideGetBar0();
+ foo.wideSetBar2ReturnDummyArg1(1,sum);
+ sum += foo.wideGetBar0();
+ foo.wideSetBar3ReturnDummyArg2(1,2,sum);
+ sum += foo.wideGetBar0();
+ foo.wideSetBar4ReturnDummyArg3(1,2,3,sum);
+ sum += foo.wideGetBar0();
+ foo.wideSetBar5ReturnDummyArg4(1,2,3,4,sum);
+ sum += foo.wideGetBar0();
+ foo.wideSetBar2iReturnDummyArg1(1,sum);
+ sum += foo.wideGetBar0();
+ foo.wideSetBar3iReturnDummyArg2(1,2,sum);
+ sum += foo.wideGetBar0();
+ foo.wideSetBar4iReturnDummyArg3(1,2,3,sum);
+ sum += foo.wideGetBar0();
+ foo.wideSetBar5iReturnDummyArg4(1,2,3,4,sum);
+ sum += foo.wideGetBar0();
+ Foo nullFoo = Foo.getNullFoo();
+ try {
+ nullFoo.wideSetBar1ReturnThis(sum);
+ } catch(NullPointerException npe) {
+ sum += 404;
+ }
+ try {
+ nullFoo.wideSetBar2ReturnThis(1, sum);
+ } catch(NullPointerException npe) {
+ sum += 2 * 404;
+ }
+ try {
+ nullFoo.wideSetBar3ReturnThis(1, 2, sum);
+ } catch(NullPointerException npe) {
+ sum += 3 * 404;
+ }
+ try {
+ nullFoo.wideSetBar4ReturnThis(1, 2, 3, sum);
+ } catch(NullPointerException npe) {
+ sum += 4 * 404;
+ }
+ try {
+ nullFoo.wideSetBar5ReturnThis(1, 2, 3, 4, sum);
+ } catch(NullPointerException npe) {
+ sum += 5 * 404;
+ }
+ try {
+ nullFoo.wideSetBar1ReturnBarArg(sum);
+ } catch(NullPointerException npe) {
+ sum += 6 * 404;
+ }
+ try {
+ nullFoo.wideSetBar2ReturnBarArg(1, sum);
+ } catch(NullPointerException npe) {
+ sum += 7 * 404;
+ }
+ try {
+ nullFoo.wideSetBar3ReturnBarArg(1, 2, sum);
+ } catch(NullPointerException npe) {
+ sum += 8 * 404;
+ }
+ try {
+ nullFoo.wideSetBar4ReturnBarArg(1, 2, 3, sum);
+ } catch(NullPointerException npe) {
+ sum += 9 * 404;
+ }
+ try {
+ nullFoo.wideSetBar5ReturnBarArg(1, 2, 3, 4, sum);
+ } catch(NullPointerException npe) {
+ sum += 10 * 404;
+ }
+ try {
+ nullFoo.wideSetBar2iReturnBarArg(1, sum);
+ } catch(NullPointerException npe) {
+ sum += 11 * 404;
+ }
+ try {
+ nullFoo.wideSetBar3iReturnBarArg(1, 2, sum);
+ } catch(NullPointerException npe) {
+ sum += 12 * 404;
+ }
+ try {
+ nullFoo.wideSetBar4iReturnBarArg(1, 2, 3, sum);
+ } catch(NullPointerException npe) {
+ sum += 13 * 404;
+ }
+ try {
+ nullFoo.wideSetBar5iReturnBarArg(1, 2, 3, 4, sum);
+ } catch(NullPointerException npe) {
+ sum += 14 * 404;
+ }
+ try {
+ nullFoo.wideSetBar2ReturnDummyArg1(1, sum);
+ } catch(NullPointerException npe) {
+ sum += 15 * 404;
+ }
+ try {
+ nullFoo.wideSetBar3ReturnDummyArg2(1, 2, sum);
+ } catch(NullPointerException npe) {
+ sum += 16 * 404;
+ }
+ try {
+ nullFoo.wideSetBar4ReturnDummyArg3(1, 2, 3, sum);
+ } catch(NullPointerException npe) {
+ sum += 17 * 404;
+ }
+ try {
+ nullFoo.wideSetBar5ReturnDummyArg4(1, 2, 3, 4, sum);
+ } catch(NullPointerException npe) {
+ sum += 18 * 404;
+ }
+ try {
+ nullFoo.wideSetBar2iReturnDummyArg1(1, sum);
+ } catch(NullPointerException npe) {
+ sum += 19 * 404;
+ }
+ try {
+ nullFoo.wideSetBar3iReturnDummyArg2(1, 2, sum);
+ } catch(NullPointerException npe) {
+ sum += 20 * 404;
+ }
+ try {
+ nullFoo.wideSetBar4iReturnDummyArg3(1, 2, 3, sum);
+ } catch(NullPointerException npe) {
+ sum += 21 * 404;
+ }
+ try {
+ nullFoo.wideSetBar5iReturnDummyArg4(1, 2, 3, 4, sum);
+ } catch(NullPointerException npe) {
+ sum += 22 * 404;
+ }
+ long expected = (1234L << 23) + 404 * (23 * 22 / 2);
+ if (sum == expected) {
+ System.out.println("wideSetterTestWithReturnArgIgnoreReturn passes");
+ }
+ else {
+ System.out.println("wideSetterTestWithReturnArgIgnoreReturn fails: " + sum +
+ " (expecting " + expected + ")");
+ }
+ }
+
+ static void wideSetterTestWithReturnArgUseReturn() {
+ Foo foo = new Foo();
+ long sum = foo.wideGetBar0();
+ long sumDummy = 0;
+ sum += foo.wideGetBar0();
+ Foo foo2 = foo.wideSetBar1ReturnThis(sum);
+ sum += foo2.wideGetBar0();
+ foo = foo2.wideSetBar2ReturnThis(1,sum);
+ sum += foo.wideGetBar0();
+ foo2 = foo.wideSetBar3ReturnThis(1,2,sum);
+ sum += foo2.wideGetBar0();
+ foo = foo2.wideSetBar4ReturnThis(1,2,3,sum);
+ sum += foo.wideGetBar0();
+ foo = foo.wideSetBar5ReturnThis(1,2,3,4,sum);
+ sum += foo.wideGetBar0();
+ sum += foo.wideSetBar1ReturnBarArg(sum);
+ sum += foo.wideGetBar0();
+ sum += foo.wideSetBar2ReturnBarArg(1,sum);
+ sum += foo.wideGetBar0();
+ sum += foo.wideSetBar3ReturnBarArg(1,2,sum);
+ sum += foo.wideGetBar0();
+ sum += foo.wideSetBar4ReturnBarArg(1,2,3,sum);
+ sum += foo.wideGetBar0();
+ sum += foo.wideSetBar5ReturnBarArg(1,2,3,4,sum);
+ sum += foo.wideGetBar0();
+ sum += foo.wideSetBar2iReturnBarArg(1,sum);
+ sum += foo.wideGetBar0();
+ sum += foo.wideSetBar3iReturnBarArg(1,2,sum);
+ sum += foo.wideGetBar0();
+ sum += foo.wideSetBar4iReturnBarArg(1,2,3,sum);
+ sum += foo.wideGetBar0();
+ sum += foo.wideSetBar5iReturnBarArg(1,2,3,4,sum);
+ sum += foo.wideGetBar0();
+ sumDummy += foo.wideSetBar2ReturnDummyArg1(1,sum);
+ sum += foo.wideGetBar0();
+ sumDummy += foo.wideSetBar3ReturnDummyArg2(1,2,sum);
+ sum += foo.wideGetBar0();
+ sumDummy += foo.wideSetBar4ReturnDummyArg3(1,2,3,sum);
+ sum += foo.wideGetBar0();
+ sumDummy += foo.wideSetBar5ReturnDummyArg4(1,2,3,4,sum);
+ sum += foo.wideGetBar0();
+ sumDummy += foo.wideSetBar2iReturnDummyArg1(1,sum);
+ sum += foo.wideGetBar0();
+ sumDummy += foo.wideSetBar3iReturnDummyArg2(1,2,sum);
+ sum += foo.wideGetBar0();
+ sumDummy += foo.wideSetBar4iReturnDummyArg3(1,2,3,sum);
+ sum += foo.wideGetBar0();
+ sumDummy += foo.wideSetBar5iReturnDummyArg4(1,2,3,4,sum);
+ sum += foo.wideGetBar0();
+ Foo nullFoo = Foo.getNullFoo();
+ try {
+ foo = nullFoo.wideSetBar1ReturnThis(sum);
+ } catch(NullPointerException npe) {
+ sum += 404;
+ }
+ try {
+ foo = nullFoo.wideSetBar2ReturnThis(1, sum);
+ } catch(NullPointerException npe) {
+ sum += 2 * 404;
+ }
+ try {
+ foo = nullFoo.wideSetBar3ReturnThis(1, 2, sum);
+ } catch(NullPointerException npe) {
+ sum += 3 * 404;
+ }
+ try {
+ foo = nullFoo.wideSetBar4ReturnThis(1, 2, 3, sum);
+ } catch(NullPointerException npe) {
+ sum += 4 * 404;
+ }
+ try {
+ foo = nullFoo.wideSetBar5ReturnThis(1, 2, 3, 4, sum);
+ } catch(NullPointerException npe) {
+ sum += 5 * 404;
+ }
+ try {
+ sum += nullFoo.wideSetBar1ReturnBarArg(sum);
+ } catch(NullPointerException npe) {
+ sum += 6 * 404;
+ }
+ try {
+ sum += nullFoo.wideSetBar2ReturnBarArg(1, sum);
+ } catch(NullPointerException npe) {
+ sum += 7 * 404;
+ }
+ try {
+ sum += nullFoo.wideSetBar3ReturnBarArg(1, 2, sum);
+ } catch(NullPointerException npe) {
+ sum += 8 * 404;
+ }
+ try {
+ sum += nullFoo.wideSetBar4ReturnBarArg(1, 2, 3, sum);
+ } catch(NullPointerException npe) {
+ sum += 9 * 404;
+ }
+ try {
+ sum += nullFoo.wideSetBar5ReturnBarArg(1, 2, 3, 4, sum);
+ } catch(NullPointerException npe) {
+ sum += 10 * 404;
+ }
+ try {
+ sum += nullFoo.wideSetBar2iReturnBarArg(1, sum);
+ } catch(NullPointerException npe) {
+ sum += 11 * 404;
+ }
+ try {
+ sum += nullFoo.wideSetBar3iReturnBarArg(1, 2, sum);
+ } catch(NullPointerException npe) {
+ sum += 12 * 404;
+ }
+ try {
+ sum += nullFoo.wideSetBar4iReturnBarArg(1, 2, 3, sum);
+ } catch(NullPointerException npe) {
+ sum += 13 * 404;
+ }
+ try {
+ sum += nullFoo.wideSetBar5iReturnBarArg(1, 2, 3, 4, sum);
+ } catch(NullPointerException npe) {
+ sum += 14 * 404;
+ }
+ try {
+ sumDummy += nullFoo.wideSetBar2ReturnDummyArg1(1, sum);
+ } catch(NullPointerException npe) {
+ sum += 15 * 404;
+ }
+ try {
+ sumDummy += nullFoo.wideSetBar3ReturnDummyArg2(1, 2, sum);
+ } catch(NullPointerException npe) {
+ sum += 16 * 404;
+ }
+ try {
+ sumDummy += nullFoo.wideSetBar4ReturnDummyArg3(1, 2, 3, sum);
+ } catch(NullPointerException npe) {
+ sum += 17 * 404;
+ }
+ try {
+ sumDummy += nullFoo.wideSetBar5ReturnDummyArg4(1, 2, 3, 4, sum);
+ } catch(NullPointerException npe) {
+ sum += 18 * 404;
+ }
+ try {
+ sumDummy += nullFoo.wideSetBar2iReturnDummyArg1(1, sum);
+ } catch(NullPointerException npe) {
+ sum += 19 * 404;
+ }
+ try {
+ sumDummy += nullFoo.wideSetBar3iReturnDummyArg2(1, 2, sum);
+ } catch(NullPointerException npe) {
+ sum += 20 * 404;
+ }
+ try {
+ sumDummy += nullFoo.wideSetBar4iReturnDummyArg3(1, 2, 3, sum);
+ } catch(NullPointerException npe) {
+ sum += 21 * 404;
+ }
+ try {
+ sumDummy += nullFoo.wideSetBar5iReturnDummyArg4(1, 2, 3, 4, sum);
+ } catch(NullPointerException npe) {
+ sum += 22 * 404;
+ }
+ long expected = (1234L << 14) * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 + 404 * (23 * 22 / 2);
+ long expectedDummy = 2 * (5 * 4 / 2);
+ if (sum == expected && sumDummy == expectedDummy) {
+ System.out.println("wideSetterTestWithReturnArgUseReturn passes");
+ }
+ else {
+ System.out.println("wideSetterTestWithReturnArgUseReturn fails: " + sum +
+ " (expecting " + expected + "), sumDummy = " + sumDummy +
+ "(expecting " + expectedDummy + ")");
+ }
+ }
+
static void mulBy1Test() {
long res;
long j = 1;
@@ -8645,6 +9219,12 @@
private int bar = 1234;
private long lbar = 1234;
+ public static Foo getNullFoo() {
+ // Make this a bit complicated so that it's not inlined.
+ Foo foo = new Foo();
+ return (barBar(foo) != 0) ? null : foo;
+ }
+
// Looks similar to a direct method, make sure we're null checking
static int barBar(Foo foo) {
return foo.bar;
@@ -8786,6 +9366,166 @@
public long wideIdent5(int a6, int a5, int a4, int a3, int a2, long a1) {
return a1;
}
+ public Foo setBar1ReturnThis(int a1) {
+ bar = a1;
+ return this;
+ }
+ public Foo setBar2ReturnThis(int a1, int a2) {
+ bar = a2;
+ return this;
+ }
+ public Foo setBar3ReturnThis(int a1, int a2, int a3) {
+ bar = a3;
+ return this;
+ }
+ public Foo setBar4ReturnThis(int a1, int a2, int a3, int a4) {
+ bar = a4;
+ return this;
+ }
+ public Foo setBar5ReturnThis(int a1, int a2, int a3, int a4, int a5) {
+ bar = a5;
+ return this;
+ }
+ public Foo wideSetBar1ReturnThis(long a1) {
+ lbar = a1;
+ return this;
+ }
+ public Foo wideSetBar2ReturnThis(long a1, long a2) {
+ lbar = a2;
+ return this;
+ }
+ public Foo wideSetBar3ReturnThis(long a1, long a2, long a3) {
+ lbar = a3;
+ return this;
+ }
+ public Foo wideSetBar4ReturnThis(long a1, long a2, long a3, long a4) {
+ lbar = a4;
+ return this;
+ }
+ public Foo wideSetBar5ReturnThis(long a1, long a2, long a3, long a4, long a5) {
+ lbar = a5;
+ return this;
+ }
+ public Foo wideSetBar2iReturnThis(int a1, long a2) {
+ lbar = a2;
+ return this;
+ }
+ public Foo wideSetBar3iReturnThis(int a1, int a2, long a3) {
+ lbar = a3;
+ return this;
+ }
+ public Foo wideSetBar4iReturnThis(int a1, int a2, int a3, long a4) {
+ lbar = a4;
+ return this;
+ }
+ public Foo wideSetBar5iReturnThis(int a1, int a2, int a3, int a4, long a5) {
+ lbar = a5;
+ return this;
+ }
+ public int setBar1ReturnBarArg(int a1) {
+ bar = a1;
+ return a1;
+ }
+ public int setBar2ReturnBarArg(int a1, int a2) {
+ bar = a2;
+ return a2;
+ }
+ public int setBar3ReturnBarArg(int a1, int a2, int a3) {
+ bar = a3;
+ return a3;
+ }
+ public int setBar4ReturnBarArg(int a1, int a2, int a3, int a4) {
+ bar = a4;
+ return a4;
+ }
+ public int setBar5ReturnBarArg(int a1, int a2, int a3, int a4, int a5) {
+ bar = a5;
+ return a5;
+ }
+ public long wideSetBar1ReturnBarArg(long a1) {
+ lbar = a1;
+ return a1;
+ }
+ public long wideSetBar2ReturnBarArg(long a1, long a2) {
+ lbar = a2;
+ return a2;
+ }
+ public long wideSetBar3ReturnBarArg(long a1, long a2, long a3) {
+ lbar = a3;
+ return a3;
+ }
+ public long wideSetBar4ReturnBarArg(long a1, long a2, long a3, long a4) {
+ lbar = a4;
+ return a4;
+ }
+ public long wideSetBar5ReturnBarArg(long a1, long a2, long a3, long a4, long a5) {
+ lbar = a5;
+ return a5;
+ }
+ public long wideSetBar2iReturnBarArg(int a1, long a2) {
+ lbar = a2;
+ return a2;
+ }
+ public long wideSetBar3iReturnBarArg(int a1, int a2, long a3) {
+ lbar = a3;
+ return a3;
+ }
+ public long wideSetBar4iReturnBarArg(int a1, int a2, int a3, long a4) {
+ lbar = a4;
+ return a4;
+ }
+ public long wideSetBar5iReturnBarArg(int a1, int a2, int a3, int a4, long a5) {
+ lbar = a5;
+ return a5;
+ }
+ public int setBar2ReturnDummyArg1(int a1, int a2) {
+ bar = a2;
+ return a1;
+ }
+ public int setBar3ReturnDummyArg2(int a1, int a2, int a3) {
+ bar = a3;
+ return a2;
+ }
+ public int setBar4ReturnDummyArg3(int a1, int a2, int a3, int a4) {
+ bar = a4;
+ return a3;
+ }
+ public int setBar5ReturnDummyArg4(int a1, int a2, int a3, int a4, int a5) {
+ bar = a5;
+ return a4;
+ }
+ public long wideSetBar2ReturnDummyArg1(long a1, long a2) {
+ lbar = a2;
+ return a1;
+ }
+ public long wideSetBar3ReturnDummyArg2(long a1, long a2, long a3) {
+ lbar = a3;
+ return a2;
+ }
+ public long wideSetBar4ReturnDummyArg3(long a1, long a2, long a3, long a4) {
+ lbar = a4;
+ return a3;
+ }
+ public long wideSetBar5ReturnDummyArg4(long a1, long a2, long a3, long a4, long a5) {
+ lbar = a5;
+ return a4;
+ }
+ public int wideSetBar2iReturnDummyArg1(int a1, long a2) {
+ lbar = a2;
+ return a1;
+ }
+ public int wideSetBar3iReturnDummyArg2(int a1, int a2, long a3) {
+ lbar = a3;
+ return a2;
+ }
+ public int wideSetBar4iReturnDummyArg3(int a1, int a2, int a3, long a4) {
+ lbar = a4;
+ return a3;
+ }
+ public int wideSetBar5iReturnDummyArg4(int a1, int a2, int a3, int a4, long a5) {
+ lbar = a5;
+ return a4;
+ }
}
class LVNTests {
