Quick Compiler: Shoot the Camel
Another step towards moving the Quick Compiler from the old
Dalvik coding style to Art's coding style. In this CL, Camel-case
locals, struct variables and arguments are converted to lower-case
with underscore names. Most of the name changes were formulistic,
but I also took this opportunity to change the old "printMe" into
the more traditional "verbose", and shorten cUnit to cu.
No logic changes.
Change-Id: I64b69b28a8357d5cc0abc1dc975954c91abd9b45
diff --git a/src/compiler/codegen/method_codegen_driver.cc b/src/compiler/codegen/method_codegen_driver.cc
index 3808a35..9f7f692 100644
--- a/src/compiler/codegen/method_codegen_driver.cc
+++ b/src/compiler/codegen/method_codegen_driver.cc
@@ -23,35 +23,35 @@
namespace art {
-// TODO: unify badLoc
-const RegLocation badLoc = {kLocDalvikFrame, 0, 0, 0, 0, 0, 0, 0, 0,
+// TODO: unify bad_loc
+const RegLocation bad_loc = {kLocDalvikFrame, 0, 0, 0, 0, 0, 0, 0, 0,
INVALID_REG, INVALID_REG, INVALID_SREG,
INVALID_SREG};
/* Mark register usage state and return long retloc */
-RegLocation GetReturnWide(CompilationUnit* cUnit, bool isDouble)
+RegLocation GetReturnWide(CompilationUnit* cu, bool is_double)
{
RegLocation gpr_res = LocCReturnWide();
RegLocation fpr_res = LocCReturnDouble();
- RegLocation res = isDouble ? fpr_res : gpr_res;
- Clobber(cUnit, res.lowReg);
- Clobber(cUnit, res.highReg);
- LockTemp(cUnit, res.lowReg);
- LockTemp(cUnit, res.highReg);
- MarkPair(cUnit, res.lowReg, res.highReg);
+ RegLocation res = is_double ? fpr_res : gpr_res;
+ Clobber(cu, res.low_reg);
+ Clobber(cu, res.high_reg);
+ LockTemp(cu, res.low_reg);
+ LockTemp(cu, res.high_reg);
+ MarkPair(cu, res.low_reg, res.high_reg);
return res;
}
-RegLocation GetReturn(CompilationUnit* cUnit, bool isFloat)
+RegLocation GetReturn(CompilationUnit* cu, bool is_float)
{
RegLocation gpr_res = LocCReturn();
RegLocation fpr_res = LocCReturnFloat();
- RegLocation res = isFloat ? fpr_res : gpr_res;
- Clobber(cUnit, res.lowReg);
- if (cUnit->instructionSet == kMips) {
- MarkInUse(cUnit, res.lowReg);
+ RegLocation res = is_float ? fpr_res : gpr_res;
+ Clobber(cu, res.low_reg);
+ if (cu->instruction_set == kMips) {
+ MarkInUse(cu, res.low_reg);
} else {
- LockTemp(cUnit, res.lowReg);
+ LockTemp(cu, res.low_reg);
}
return res;
}
@@ -61,53 +61,53 @@
* load/store utilities here, or target-dependent genXX() handlers
* when necessary.
*/
-static bool CompileDalvikInstruction(CompilationUnit* cUnit, MIR* mir, BasicBlock* bb,
- LIR* labelList)
+static bool CompileDalvikInstruction(CompilationUnit* cu, MIR* mir, BasicBlock* bb,
+ LIR* label_list)
{
bool res = false; // Assume success
- RegLocation rlSrc[3];
- RegLocation rlDest = badLoc;
- RegLocation rlResult = badLoc;
+ RegLocation rl_src[3];
+ RegLocation rl_dest = bad_loc;
+ RegLocation rl_result = bad_loc;
Instruction::Code opcode = mir->dalvikInsn.opcode;
- int optFlags = mir->optimizationFlags;
+ int opt_flags = mir->optimization_flags;
uint32_t vB = mir->dalvikInsn.vB;
uint32_t vC = mir->dalvikInsn.vC;
/* Prep Src and Dest locations */
- int nextSreg = 0;
- int nextLoc = 0;
- int attrs = oatDataFlowAttributes[opcode];
- rlSrc[0] = rlSrc[1] = rlSrc[2] = badLoc;
+ int next_sreg = 0;
+ int next_loc = 0;
+ int attrs = oat_data_flow_attributes[opcode];
+ rl_src[0] = rl_src[1] = rl_src[2] = bad_loc;
if (attrs & DF_UA) {
if (attrs & DF_A_WIDE) {
- rlSrc[nextLoc++] = GetSrcWide(cUnit, mir, nextSreg);
- nextSreg+= 2;
+ rl_src[next_loc++] = GetSrcWide(cu, mir, next_sreg);
+ next_sreg+= 2;
} else {
- rlSrc[nextLoc++] = GetSrc(cUnit, mir, nextSreg);
- nextSreg++;
+ rl_src[next_loc++] = GetSrc(cu, mir, next_sreg);
+ next_sreg++;
}
}
if (attrs & DF_UB) {
if (attrs & DF_B_WIDE) {
- rlSrc[nextLoc++] = GetSrcWide(cUnit, mir, nextSreg);
- nextSreg+= 2;
+ rl_src[next_loc++] = GetSrcWide(cu, mir, next_sreg);
+ next_sreg+= 2;
} else {
- rlSrc[nextLoc++] = GetSrc(cUnit, mir, nextSreg);
- nextSreg++;
+ rl_src[next_loc++] = GetSrc(cu, mir, next_sreg);
+ next_sreg++;
}
}
if (attrs & DF_UC) {
if (attrs & DF_C_WIDE) {
- rlSrc[nextLoc++] = GetSrcWide(cUnit, mir, nextSreg);
+ rl_src[next_loc++] = GetSrcWide(cu, mir, next_sreg);
} else {
- rlSrc[nextLoc++] = GetSrc(cUnit, mir, nextSreg);
+ rl_src[next_loc++] = GetSrc(cu, mir, next_sreg);
}
}
if (attrs & DF_DA) {
if (attrs & DF_A_WIDE) {
- rlDest = GetDestWide(cUnit, mir);
+ rl_dest = GetDestWide(cu, mir);
} else {
- rlDest = GetDest(cUnit, mir);
+ rl_dest = GetDest(cu, mir);
}
}
switch (opcode) {
@@ -115,41 +115,41 @@
break;
case Instruction::MOVE_EXCEPTION:
- GenMoveException(cUnit, rlDest);
+ GenMoveException(cu, rl_dest);
break;
case Instruction::RETURN_VOID:
- if (!(cUnit->attrs & METHOD_IS_LEAF)) {
- GenSuspendTest(cUnit, optFlags);
+ if (!(cu->attrs & METHOD_IS_LEAF)) {
+ GenSuspendTest(cu, opt_flags);
}
break;
case Instruction::RETURN:
case Instruction::RETURN_OBJECT:
- if (!(cUnit->attrs & METHOD_IS_LEAF)) {
- GenSuspendTest(cUnit, optFlags);
+ if (!(cu->attrs & METHOD_IS_LEAF)) {
+ GenSuspendTest(cu, opt_flags);
}
- StoreValue(cUnit, GetReturn(cUnit, cUnit->shorty[0] == 'F'), rlSrc[0]);
+ StoreValue(cu, GetReturn(cu, cu->shorty[0] == 'F'), rl_src[0]);
break;
case Instruction::RETURN_WIDE:
- if (!(cUnit->attrs & METHOD_IS_LEAF)) {
- GenSuspendTest(cUnit, optFlags);
+ if (!(cu->attrs & METHOD_IS_LEAF)) {
+ GenSuspendTest(cu, opt_flags);
}
- StoreValueWide(cUnit, GetReturnWide(cUnit,
- cUnit->shorty[0] == 'D'), rlSrc[0]);
+ StoreValueWide(cu, GetReturnWide(cu,
+ cu->shorty[0] == 'D'), rl_src[0]);
break;
case Instruction::MOVE_RESULT_WIDE:
- if (optFlags & MIR_INLINED)
+ if (opt_flags & MIR_INLINED)
break; // Nop - combined w/ previous invoke
- StoreValueWide(cUnit, rlDest, GetReturnWide(cUnit, rlDest.fp));
+ StoreValueWide(cu, rl_dest, GetReturnWide(cu, rl_dest.fp));
break;
case Instruction::MOVE_RESULT:
case Instruction::MOVE_RESULT_OBJECT:
- if (optFlags & MIR_INLINED)
+ if (opt_flags & MIR_INLINED)
break; // Nop - combined w/ previous invoke
- StoreValue(cUnit, rlDest, GetReturn(cUnit, rlDest.fp));
+ StoreValue(cu, rl_dest, GetReturn(cu, rl_dest.fp));
break;
case Instruction::MOVE:
@@ -158,140 +158,140 @@
case Instruction::MOVE_OBJECT_16:
case Instruction::MOVE_FROM16:
case Instruction::MOVE_OBJECT_FROM16:
- StoreValue(cUnit, rlDest, rlSrc[0]);
+ StoreValue(cu, rl_dest, rl_src[0]);
break;
case Instruction::MOVE_WIDE:
case Instruction::MOVE_WIDE_16:
case Instruction::MOVE_WIDE_FROM16:
- StoreValueWide(cUnit, rlDest, rlSrc[0]);
+ StoreValueWide(cu, rl_dest, rl_src[0]);
break;
case Instruction::CONST:
case Instruction::CONST_4:
case Instruction::CONST_16:
- rlResult = EvalLoc(cUnit, rlDest, kAnyReg, true);
- LoadConstantNoClobber(cUnit, rlResult.lowReg, vB);
- StoreValue(cUnit, rlDest, rlResult);
+ rl_result = EvalLoc(cu, rl_dest, kAnyReg, true);
+ LoadConstantNoClobber(cu, rl_result.low_reg, vB);
+ StoreValue(cu, rl_dest, rl_result);
break;
case Instruction::CONST_HIGH16:
- rlResult = EvalLoc(cUnit, rlDest, kAnyReg, true);
- LoadConstantNoClobber(cUnit, rlResult.lowReg, vB << 16);
- StoreValue(cUnit, rlDest, rlResult);
+ rl_result = EvalLoc(cu, rl_dest, kAnyReg, true);
+ LoadConstantNoClobber(cu, rl_result.low_reg, vB << 16);
+ StoreValue(cu, rl_dest, rl_result);
break;
case Instruction::CONST_WIDE_16:
case Instruction::CONST_WIDE_32:
- rlResult = EvalLoc(cUnit, rlDest, kAnyReg, true);
- LoadConstantValueWide(cUnit, rlResult.lowReg, rlResult.highReg, vB,
+ rl_result = EvalLoc(cu, rl_dest, kAnyReg, true);
+ LoadConstantValueWide(cu, rl_result.low_reg, rl_result.high_reg, vB,
(vB & 0x80000000) ? -1 : 0);
- StoreValueWide(cUnit, rlDest, rlResult);
+ StoreValueWide(cu, rl_dest, rl_result);
break;
case Instruction::CONST_WIDE:
- rlResult = EvalLoc(cUnit, rlDest, kAnyReg, true);
- LoadConstantValueWide(cUnit, rlResult.lowReg, rlResult.highReg,
+ rl_result = EvalLoc(cu, rl_dest, kAnyReg, true);
+ LoadConstantValueWide(cu, rl_result.low_reg, rl_result.high_reg,
mir->dalvikInsn.vB_wide & 0xffffffff,
(mir->dalvikInsn.vB_wide >> 32) & 0xffffffff);
- StoreValueWide(cUnit, rlDest, rlResult);
+ StoreValueWide(cu, rl_dest, rl_result);
break;
case Instruction::CONST_WIDE_HIGH16:
- rlResult = EvalLoc(cUnit, rlDest, kAnyReg, true);
- LoadConstantValueWide(cUnit, rlResult.lowReg, rlResult.highReg,
+ rl_result = EvalLoc(cu, rl_dest, kAnyReg, true);
+ LoadConstantValueWide(cu, rl_result.low_reg, rl_result.high_reg,
0, vB << 16);
- StoreValueWide(cUnit, rlDest, rlResult);
+ StoreValueWide(cu, rl_dest, rl_result);
break;
case Instruction::MONITOR_ENTER:
- GenMonitorEnter(cUnit, optFlags, rlSrc[0]);
+ GenMonitorEnter(cu, opt_flags, rl_src[0]);
break;
case Instruction::MONITOR_EXIT:
- GenMonitorExit(cUnit, optFlags, rlSrc[0]);
+ GenMonitorExit(cu, opt_flags, rl_src[0]);
break;
case Instruction::CHECK_CAST:
- GenCheckCast(cUnit, vB, rlSrc[0]);
+ GenCheckCast(cu, vB, rl_src[0]);
break;
case Instruction::INSTANCE_OF:
- GenInstanceof(cUnit, vC, rlDest, rlSrc[0]);
+ GenInstanceof(cu, vC, rl_dest, rl_src[0]);
break;
case Instruction::NEW_INSTANCE:
- GenNewInstance(cUnit, vB, rlDest);
+ GenNewInstance(cu, vB, rl_dest);
break;
case Instruction::THROW:
- GenThrow(cUnit, rlSrc[0]);
+ GenThrow(cu, rl_src[0]);
break;
case Instruction::ARRAY_LENGTH:
- int lenOffset;
- lenOffset = Array::LengthOffset().Int32Value();
- rlSrc[0] = LoadValue(cUnit, rlSrc[0], kCoreReg);
- GenNullCheck(cUnit, rlSrc[0].sRegLow, rlSrc[0].lowReg, optFlags);
- rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
- LoadWordDisp(cUnit, rlSrc[0].lowReg, lenOffset, rlResult.lowReg);
- StoreValue(cUnit, rlDest, rlResult);
+ int len_offset;
+ len_offset = Array::LengthOffset().Int32Value();
+ rl_src[0] = LoadValue(cu, rl_src[0], kCoreReg);
+ GenNullCheck(cu, rl_src[0].s_reg_low, rl_src[0].low_reg, opt_flags);
+ rl_result = EvalLoc(cu, rl_dest, kCoreReg, true);
+ LoadWordDisp(cu, rl_src[0].low_reg, len_offset, rl_result.low_reg);
+ StoreValue(cu, rl_dest, rl_result);
break;
case Instruction::CONST_STRING:
case Instruction::CONST_STRING_JUMBO:
- GenConstString(cUnit, vB, rlDest);
+ GenConstString(cu, vB, rl_dest);
break;
case Instruction::CONST_CLASS:
- GenConstClass(cUnit, vB, rlDest);
+ GenConstClass(cu, vB, rl_dest);
break;
case Instruction::FILL_ARRAY_DATA:
- GenFillArrayData(cUnit, vB, rlSrc[0]);
+ GenFillArrayData(cu, vB, rl_src[0]);
break;
case Instruction::FILLED_NEW_ARRAY:
- GenFilledNewArray(cUnit, NewMemCallInfo(cUnit, bb, mir, kStatic,
+ GenFilledNewArray(cu, NewMemCallInfo(cu, bb, mir, kStatic,
false /* not range */));
break;
case Instruction::FILLED_NEW_ARRAY_RANGE:
- GenFilledNewArray(cUnit, NewMemCallInfo(cUnit, bb, mir, kStatic,
+ GenFilledNewArray(cu, NewMemCallInfo(cu, bb, mir, kStatic,
true /* range */));
break;
case Instruction::NEW_ARRAY:
- GenNewArray(cUnit, vC, rlDest, rlSrc[0]);
+ GenNewArray(cu, vC, rl_dest, rl_src[0]);
break;
case Instruction::GOTO:
case Instruction::GOTO_16:
case Instruction::GOTO_32:
- if (bb->taken->startOffset <= mir->offset) {
- GenSuspendTestAndBranch(cUnit, optFlags, &labelList[bb->taken->id]);
+ if (bb->taken->start_offset <= mir->offset) {
+ GenSuspendTestAndBranch(cu, opt_flags, &label_list[bb->taken->id]);
} else {
- OpUnconditionalBranch(cUnit, &labelList[bb->taken->id]);
+ OpUnconditionalBranch(cu, &label_list[bb->taken->id]);
}
break;
case Instruction::PACKED_SWITCH:
- GenPackedSwitch(cUnit, vB, rlSrc[0]);
+ GenPackedSwitch(cu, vB, rl_src[0]);
break;
case Instruction::SPARSE_SWITCH:
- GenSparseSwitch(cUnit, vB, rlSrc[0]);
+ GenSparseSwitch(cu, vB, rl_src[0]);
break;
case Instruction::CMPL_FLOAT:
case Instruction::CMPG_FLOAT:
case Instruction::CMPL_DOUBLE:
case Instruction::CMPG_DOUBLE:
- res = GenCmpFP(cUnit, opcode, rlDest, rlSrc[0], rlSrc[1]);
+ res = GenCmpFP(cu, opcode, rl_dest, rl_src[0], rl_src[1]);
break;
case Instruction::CMP_LONG:
- GenCmpLong(cUnit, rlDest, rlSrc[0], rlSrc[1]);
+ GenCmpLong(cu, rl_dest, rl_src[0], rl_src[1]);
break;
case Instruction::IF_EQ:
@@ -300,15 +300,15 @@
case Instruction::IF_GE:
case Instruction::IF_GT:
case Instruction::IF_LE: {
- LIR* taken = &labelList[bb->taken->id];
- LIR* fallThrough = &labelList[bb->fallThrough->id];
- bool backwardBranch;
- backwardBranch = (bb->taken->startOffset <= mir->offset);
- if (backwardBranch) {
- GenSuspendTest(cUnit, optFlags);
+ LIR* taken = &label_list[bb->taken->id];
+ LIR* fall_through = &label_list[bb->fall_through->id];
+ bool backward_branch;
+ backward_branch = (bb->taken->start_offset <= mir->offset);
+ if (backward_branch) {
+ GenSuspendTest(cu, opt_flags);
}
- GenCompareAndBranch(cUnit, opcode, rlSrc[0], rlSrc[1], taken,
- fallThrough);
+ GenCompareAndBranch(cu, opcode, rl_src[0], rl_src[1], taken,
+ fall_through);
break;
}
@@ -318,128 +318,128 @@
case Instruction::IF_GEZ:
case Instruction::IF_GTZ:
case Instruction::IF_LEZ: {
- LIR* taken = &labelList[bb->taken->id];
- LIR* fallThrough = &labelList[bb->fallThrough->id];
- bool backwardBranch;
- backwardBranch = (bb->taken->startOffset <= mir->offset);
- if (backwardBranch) {
- GenSuspendTest(cUnit, optFlags);
+ LIR* taken = &label_list[bb->taken->id];
+ LIR* fall_through = &label_list[bb->fall_through->id];
+ bool backward_branch;
+ backward_branch = (bb->taken->start_offset <= mir->offset);
+ if (backward_branch) {
+ GenSuspendTest(cu, opt_flags);
}
- GenCompareZeroAndBranch(cUnit, opcode, rlSrc[0], taken, fallThrough);
+ GenCompareZeroAndBranch(cu, opcode, rl_src[0], taken, fall_through);
break;
}
case Instruction::AGET_WIDE:
- GenArrayGet(cUnit, optFlags, kLong, rlSrc[0], rlSrc[1], rlDest, 3);
+ GenArrayGet(cu, opt_flags, kLong, rl_src[0], rl_src[1], rl_dest, 3);
break;
case Instruction::AGET:
case Instruction::AGET_OBJECT:
- GenArrayGet(cUnit, optFlags, kWord, rlSrc[0], rlSrc[1], rlDest, 2);
+ GenArrayGet(cu, opt_flags, kWord, rl_src[0], rl_src[1], rl_dest, 2);
break;
case Instruction::AGET_BOOLEAN:
- GenArrayGet(cUnit, optFlags, kUnsignedByte, rlSrc[0], rlSrc[1], rlDest, 0);
+ GenArrayGet(cu, opt_flags, kUnsignedByte, rl_src[0], rl_src[1], rl_dest, 0);
break;
case Instruction::AGET_BYTE:
- GenArrayGet(cUnit, optFlags, kSignedByte, rlSrc[0], rlSrc[1], rlDest, 0);
+ GenArrayGet(cu, opt_flags, kSignedByte, rl_src[0], rl_src[1], rl_dest, 0);
break;
case Instruction::AGET_CHAR:
- GenArrayGet(cUnit, optFlags, kUnsignedHalf, rlSrc[0], rlSrc[1], rlDest, 1);
+ GenArrayGet(cu, opt_flags, kUnsignedHalf, rl_src[0], rl_src[1], rl_dest, 1);
break;
case Instruction::AGET_SHORT:
- GenArrayGet(cUnit, optFlags, kSignedHalf, rlSrc[0], rlSrc[1], rlDest, 1);
+ GenArrayGet(cu, opt_flags, kSignedHalf, rl_src[0], rl_src[1], rl_dest, 1);
break;
case Instruction::APUT_WIDE:
- GenArrayPut(cUnit, optFlags, kLong, rlSrc[1], rlSrc[2], rlSrc[0], 3);
+ GenArrayPut(cu, opt_flags, kLong, rl_src[1], rl_src[2], rl_src[0], 3);
break;
case Instruction::APUT:
- GenArrayPut(cUnit, optFlags, kWord, rlSrc[1], rlSrc[2], rlSrc[0], 2);
+ GenArrayPut(cu, opt_flags, kWord, rl_src[1], rl_src[2], rl_src[0], 2);
break;
case Instruction::APUT_OBJECT:
- GenArrayObjPut(cUnit, optFlags, rlSrc[1], rlSrc[2], rlSrc[0], 2);
+ GenArrayObjPut(cu, opt_flags, rl_src[1], rl_src[2], rl_src[0], 2);
break;
case Instruction::APUT_SHORT:
case Instruction::APUT_CHAR:
- GenArrayPut(cUnit, optFlags, kUnsignedHalf, rlSrc[1], rlSrc[2], rlSrc[0], 1);
+ GenArrayPut(cu, opt_flags, kUnsignedHalf, rl_src[1], rl_src[2], rl_src[0], 1);
break;
case Instruction::APUT_BYTE:
case Instruction::APUT_BOOLEAN:
- GenArrayPut(cUnit, optFlags, kUnsignedByte, rlSrc[1], rlSrc[2],
- rlSrc[0], 0);
+ GenArrayPut(cu, opt_flags, kUnsignedByte, rl_src[1], rl_src[2],
+ rl_src[0], 0);
break;
case Instruction::IGET_OBJECT:
//case Instruction::IGET_OBJECT_VOLATILE:
- GenIGet(cUnit, vC, optFlags, kWord, rlDest, rlSrc[0], false, true);
+ GenIGet(cu, vC, opt_flags, kWord, rl_dest, rl_src[0], false, true);
break;
case Instruction::IGET_WIDE:
//case Instruction::IGET_WIDE_VOLATILE:
- GenIGet(cUnit, vC, optFlags, kLong, rlDest, rlSrc[0], true, false);
+ GenIGet(cu, vC, opt_flags, kLong, rl_dest, rl_src[0], true, false);
break;
case Instruction::IGET:
//case Instruction::IGET_VOLATILE:
- GenIGet(cUnit, vC, optFlags, kWord, rlDest, rlSrc[0], false, false);
+ GenIGet(cu, vC, opt_flags, kWord, rl_dest, rl_src[0], false, false);
break;
case Instruction::IGET_CHAR:
- GenIGet(cUnit, vC, optFlags, kUnsignedHalf, rlDest, rlSrc[0], false, false);
+ GenIGet(cu, vC, opt_flags, kUnsignedHalf, rl_dest, rl_src[0], false, false);
break;
case Instruction::IGET_SHORT:
- GenIGet(cUnit, vC, optFlags, kSignedHalf, rlDest, rlSrc[0], false, false);
+ GenIGet(cu, vC, opt_flags, kSignedHalf, rl_dest, rl_src[0], false, false);
break;
case Instruction::IGET_BOOLEAN:
case Instruction::IGET_BYTE:
- GenIGet(cUnit, vC, optFlags, kUnsignedByte, rlDest, rlSrc[0], false, false);
+ GenIGet(cu, vC, opt_flags, kUnsignedByte, rl_dest, rl_src[0], false, false);
break;
case Instruction::IPUT_WIDE:
//case Instruction::IPUT_WIDE_VOLATILE:
- GenIPut(cUnit, vC, optFlags, kLong, rlSrc[0], rlSrc[1], true, false);
+ GenIPut(cu, vC, opt_flags, kLong, rl_src[0], rl_src[1], true, false);
break;
case Instruction::IPUT_OBJECT:
//case Instruction::IPUT_OBJECT_VOLATILE:
- GenIPut(cUnit, vC, optFlags, kWord, rlSrc[0], rlSrc[1], false, true);
+ GenIPut(cu, vC, opt_flags, kWord, rl_src[0], rl_src[1], false, true);
break;
case Instruction::IPUT:
//case Instruction::IPUT_VOLATILE:
- GenIPut(cUnit, vC, optFlags, kWord, rlSrc[0], rlSrc[1], false, false);
+ GenIPut(cu, vC, opt_flags, kWord, rl_src[0], rl_src[1], false, false);
break;
case Instruction::IPUT_BOOLEAN:
case Instruction::IPUT_BYTE:
- GenIPut(cUnit, vC, optFlags, kUnsignedByte, rlSrc[0], rlSrc[1], false, false);
+ GenIPut(cu, vC, opt_flags, kUnsignedByte, rl_src[0], rl_src[1], false, false);
break;
case Instruction::IPUT_CHAR:
- GenIPut(cUnit, vC, optFlags, kUnsignedHalf, rlSrc[0], rlSrc[1], false, false);
+ GenIPut(cu, vC, opt_flags, kUnsignedHalf, rl_src[0], rl_src[1], false, false);
break;
case Instruction::IPUT_SHORT:
- GenIPut(cUnit, vC, optFlags, kSignedHalf, rlSrc[0], rlSrc[1], false, false);
+ GenIPut(cu, vC, opt_flags, kSignedHalf, rl_src[0], rl_src[1], false, false);
break;
case Instruction::SGET_OBJECT:
- GenSget(cUnit, vB, rlDest, false, true);
+ GenSget(cu, vB, rl_dest, false, true);
break;
case Instruction::SGET:
case Instruction::SGET_BOOLEAN:
case Instruction::SGET_BYTE:
case Instruction::SGET_CHAR:
case Instruction::SGET_SHORT:
- GenSget(cUnit, vB, rlDest, false, false);
+ GenSget(cu, vB, rl_dest, false, false);
break;
case Instruction::SGET_WIDE:
- GenSget(cUnit, vB, rlDest, true, false);
+ GenSget(cu, vB, rl_dest, true, false);
break;
case Instruction::SPUT_OBJECT:
- GenSput(cUnit, vB, rlSrc[0], false, true);
+ GenSput(cu, vB, rl_src[0], false, true);
break;
case Instruction::SPUT:
@@ -447,80 +447,80 @@
case Instruction::SPUT_BYTE:
case Instruction::SPUT_CHAR:
case Instruction::SPUT_SHORT:
- GenSput(cUnit, vB, rlSrc[0], false, false);
+ GenSput(cu, vB, rl_src[0], false, false);
break;
case Instruction::SPUT_WIDE:
- GenSput(cUnit, vB, rlSrc[0], true, false);
+ GenSput(cu, vB, rl_src[0], true, false);
break;
case Instruction::INVOKE_STATIC_RANGE:
- GenInvoke(cUnit, NewMemCallInfo(cUnit, bb, mir, kStatic, true));
+ GenInvoke(cu, NewMemCallInfo(cu, bb, mir, kStatic, true));
break;
case Instruction::INVOKE_STATIC:
- GenInvoke(cUnit, NewMemCallInfo(cUnit, bb, mir, kStatic, false));
+ GenInvoke(cu, NewMemCallInfo(cu, bb, mir, kStatic, false));
break;
case Instruction::INVOKE_DIRECT:
- GenInvoke(cUnit, NewMemCallInfo(cUnit, bb, mir, kDirect, false));
+ GenInvoke(cu, NewMemCallInfo(cu, bb, mir, kDirect, false));
break;
case Instruction::INVOKE_DIRECT_RANGE:
- GenInvoke(cUnit, NewMemCallInfo(cUnit, bb, mir, kDirect, true));
+ GenInvoke(cu, NewMemCallInfo(cu, bb, mir, kDirect, true));
break;
case Instruction::INVOKE_VIRTUAL:
- GenInvoke(cUnit, NewMemCallInfo(cUnit, bb, mir, kVirtual, false));
+ GenInvoke(cu, NewMemCallInfo(cu, bb, mir, kVirtual, false));
break;
case Instruction::INVOKE_VIRTUAL_RANGE:
- GenInvoke(cUnit, NewMemCallInfo(cUnit, bb, mir, kVirtual, true));
+ GenInvoke(cu, NewMemCallInfo(cu, bb, mir, kVirtual, true));
break;
case Instruction::INVOKE_SUPER:
- GenInvoke(cUnit, NewMemCallInfo(cUnit, bb, mir, kSuper, false));
+ GenInvoke(cu, NewMemCallInfo(cu, bb, mir, kSuper, false));
break;
case Instruction::INVOKE_SUPER_RANGE:
- GenInvoke(cUnit, NewMemCallInfo(cUnit, bb, mir, kSuper, true));
+ GenInvoke(cu, NewMemCallInfo(cu, bb, mir, kSuper, true));
break;
case Instruction::INVOKE_INTERFACE:
- GenInvoke(cUnit, NewMemCallInfo(cUnit, bb, mir, kInterface, false));
+ GenInvoke(cu, NewMemCallInfo(cu, bb, mir, kInterface, false));
break;
case Instruction::INVOKE_INTERFACE_RANGE:
- GenInvoke(cUnit, NewMemCallInfo(cUnit, bb, mir, kInterface, true));
+ GenInvoke(cu, NewMemCallInfo(cu, bb, mir, kInterface, true));
break;
case Instruction::NEG_INT:
case Instruction::NOT_INT:
- res = GenArithOpInt(cUnit, opcode, rlDest, rlSrc[0], rlSrc[0]);
+ res = GenArithOpInt(cu, opcode, rl_dest, rl_src[0], rl_src[0]);
break;
case Instruction::NEG_LONG:
case Instruction::NOT_LONG:
- res = GenArithOpLong(cUnit, opcode, rlDest, rlSrc[0], rlSrc[0]);
+ res = GenArithOpLong(cu, opcode, rl_dest, rl_src[0], rl_src[0]);
break;
case Instruction::NEG_FLOAT:
- res = GenArithOpFloat(cUnit, opcode, rlDest, rlSrc[0], rlSrc[0]);
+ res = GenArithOpFloat(cu, opcode, rl_dest, rl_src[0], rl_src[0]);
break;
case Instruction::NEG_DOUBLE:
- res = GenArithOpDouble(cUnit, opcode, rlDest, rlSrc[0], rlSrc[0]);
+ res = GenArithOpDouble(cu, opcode, rl_dest, rl_src[0], rl_src[0]);
break;
case Instruction::INT_TO_LONG:
- GenIntToLong(cUnit, rlDest, rlSrc[0]);
+ GenIntToLong(cu, rl_dest, rl_src[0]);
break;
case Instruction::LONG_TO_INT:
- rlSrc[0] = UpdateLocWide(cUnit, rlSrc[0]);
- rlSrc[0] = WideToNarrow(cUnit, rlSrc[0]);
- StoreValue(cUnit, rlDest, rlSrc[0]);
+ rl_src[0] = UpdateLocWide(cu, rl_src[0]);
+ rl_src[0] = WideToNarrow(cu, rl_src[0]);
+ StoreValue(cu, rl_dest, rl_src[0]);
break;
case Instruction::INT_TO_BYTE:
case Instruction::INT_TO_SHORT:
case Instruction::INT_TO_CHAR:
- GenIntNarrowing(cUnit, opcode, rlDest, rlSrc[0]);
+ GenIntNarrowing(cu, opcode, rl_dest, rl_src[0]);
break;
case Instruction::INT_TO_FLOAT:
@@ -533,7 +533,7 @@
case Instruction::DOUBLE_TO_INT:
case Instruction::DOUBLE_TO_LONG:
case Instruction::DOUBLE_TO_FLOAT:
- GenConversion(cUnit, opcode, rlDest, rlSrc[0]);
+ GenConversion(cu, opcode, rl_dest, rl_src[0]);
break;
case Instruction::ADD_INT:
@@ -558,7 +558,7 @@
case Instruction::SHL_INT_2ADDR:
case Instruction::SHR_INT_2ADDR:
case Instruction::USHR_INT_2ADDR:
- GenArithOpInt(cUnit, opcode, rlDest, rlSrc[0], rlSrc[1]);
+ GenArithOpInt(cu, opcode, rl_dest, rl_src[0], rl_src[1]);
break;
case Instruction::ADD_LONG:
@@ -577,7 +577,7 @@
case Instruction::AND_LONG_2ADDR:
case Instruction::OR_LONG_2ADDR:
case Instruction::XOR_LONG_2ADDR:
- GenArithOpLong(cUnit, opcode, rlDest, rlSrc[0], rlSrc[1]);
+ GenArithOpLong(cu, opcode, rl_dest, rl_src[0], rl_src[1]);
break;
case Instruction::SHL_LONG:
@@ -586,7 +586,7 @@
case Instruction::SHL_LONG_2ADDR:
case Instruction::SHR_LONG_2ADDR:
case Instruction::USHR_LONG_2ADDR:
- GenShiftOpLong(cUnit, opcode, rlDest, rlSrc[0], rlSrc[1]);
+ GenShiftOpLong(cu, opcode, rl_dest, rl_src[0], rl_src[1]);
break;
case Instruction::ADD_FLOAT:
@@ -599,7 +599,7 @@
case Instruction::MUL_FLOAT_2ADDR:
case Instruction::DIV_FLOAT_2ADDR:
case Instruction::REM_FLOAT_2ADDR:
- GenArithOpFloat(cUnit, opcode, rlDest, rlSrc[0], rlSrc[1]);
+ GenArithOpFloat(cu, opcode, rl_dest, rl_src[0], rl_src[1]);
break;
case Instruction::ADD_DOUBLE:
@@ -612,7 +612,7 @@
case Instruction::MUL_DOUBLE_2ADDR:
case Instruction::DIV_DOUBLE_2ADDR:
case Instruction::REM_DOUBLE_2ADDR:
- GenArithOpDouble(cUnit, opcode, rlDest, rlSrc[0], rlSrc[1]);
+ GenArithOpDouble(cu, opcode, rl_dest, rl_src[0], rl_src[1]);
break;
case Instruction::RSUB_INT:
@@ -634,7 +634,7 @@
case Instruction::SHL_INT_LIT8:
case Instruction::SHR_INT_LIT8:
case Instruction::USHR_INT_LIT8:
- GenArithOpIntLit(cUnit, opcode, rlDest, rlSrc[0], vC);
+ GenArithOpIntLit(cu, opcode, rl_dest, rl_src[0], vC);
break;
default:
@@ -644,47 +644,47 @@
}
/* Extended MIR instructions like PHI */
-static void HandleExtendedMethodMIR(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir)
+static void HandleExtendedMethodMIR(CompilationUnit* cu, BasicBlock* bb, MIR* mir)
{
- int opOffset = mir->dalvikInsn.opcode - kMirOpFirst;
+ int op_offset = mir->dalvikInsn.opcode - kMirOpFirst;
char* msg = NULL;
- if (cUnit->printMe) {
- msg = static_cast<char*>(NewMem(cUnit, strlen(extendedMIROpNames[opOffset]) + 1,
+ if (cu->verbose) {
+ msg = static_cast<char*>(NewMem(cu, strlen(extended_mir_op_names[op_offset]) + 1,
false, kAllocDebugInfo));
- strcpy(msg, extendedMIROpNames[opOffset]);
+ strcpy(msg, extended_mir_op_names[op_offset]);
}
- LIR* op = NewLIR1(cUnit, kPseudoExtended, reinterpret_cast<uintptr_t>(msg));
+ LIR* op = NewLIR1(cu, kPseudoExtended, reinterpret_cast<uintptr_t>(msg));
switch (static_cast<ExtendedMIROpcode>(mir->dalvikInsn.opcode)) {
case kMirOpPhi: {
- char* ssaString = NULL;
- if (cUnit->printMe) {
- ssaString = GetSSAString(cUnit, mir->ssaRep);
+ char* ssa_string = NULL;
+ if (cu->verbose) {
+ ssa_string = GetSSAString(cu, mir->ssa_rep);
}
- op->flags.isNop = true;
- NewLIR1(cUnit, kPseudoSSARep, reinterpret_cast<uintptr_t>(ssaString));
+ op->flags.is_nop = true;
+ NewLIR1(cu, kPseudoSSARep, reinterpret_cast<uintptr_t>(ssa_string));
break;
}
case kMirOpCopy: {
- RegLocation rlSrc = GetSrc(cUnit, mir, 0);
- RegLocation rlDest = GetDest(cUnit, mir);
- StoreValue(cUnit, rlDest, rlSrc);
+ RegLocation rl_src = GetSrc(cu, mir, 0);
+ RegLocation rl_dest = GetDest(cu, mir);
+ StoreValue(cu, rl_dest, rl_src);
break;
}
case kMirOpFusedCmplFloat:
- GenFusedFPCmpBranch(cUnit, bb, mir, false /*gt bias*/, false /*double*/);
+ GenFusedFPCmpBranch(cu, bb, mir, false /*gt bias*/, false /*double*/);
break;
case kMirOpFusedCmpgFloat:
- GenFusedFPCmpBranch(cUnit, bb, mir, true /*gt bias*/, false /*double*/);
+ GenFusedFPCmpBranch(cu, bb, mir, true /*gt bias*/, false /*double*/);
break;
case kMirOpFusedCmplDouble:
- GenFusedFPCmpBranch(cUnit, bb, mir, false /*gt bias*/, true /*double*/);
+ GenFusedFPCmpBranch(cu, bb, mir, false /*gt bias*/, true /*double*/);
break;
case kMirOpFusedCmpgDouble:
- GenFusedFPCmpBranch(cUnit, bb, mir, true /*gt bias*/, true /*double*/);
+ GenFusedFPCmpBranch(cu, bb, mir, true /*gt bias*/, true /*double*/);
break;
case kMirOpFusedCmpLong:
- GenFusedLongCmpBranch(cUnit, bb, mir);
+ GenFusedLongCmpBranch(cu, bb, mir);
break;
default:
break;
@@ -692,167 +692,167 @@
}
/* Handle the content in each basic block */
-static bool MethodBlockCodeGen(CompilationUnit* cUnit, BasicBlock* bb)
+static bool MethodBlockCodeGen(CompilationUnit* cu, BasicBlock* bb)
{
- if (bb->blockType == kDead) return false;
- cUnit->currentDalvikOffset = bb->startOffset;
+ if (bb->block_type == kDead) return false;
+ cu->current_dalvik_offset = bb->start_offset;
MIR* mir;
- LIR* labelList = cUnit->blockLabelList;
- int blockId = bb->id;
+ LIR* label_list = cu->block_label_list;
+ int block_id = bb->id;
- cUnit->curBlock = bb;
- labelList[blockId].operands[0] = bb->startOffset;
+ cu->cur_block = bb;
+ label_list[block_id].operands[0] = bb->start_offset;
/* Insert the block label */
- labelList[blockId].opcode = kPseudoNormalBlockLabel;
- AppendLIR(cUnit, &labelList[blockId]);
+ label_list[block_id].opcode = kPseudoNormalBlockLabel;
+ AppendLIR(cu, &label_list[block_id]);
- LIR* headLIR = NULL;
+ LIR* head_lir = NULL;
/* If this is a catch block, export the start address */
- if (bb->catchEntry) {
- headLIR = NewLIR0(cUnit, kPseudoExportedPC);
+ if (bb->catch_entry) {
+ head_lir = NewLIR0(cu, kPseudoExportedPC);
}
/* Free temp registers and reset redundant store tracking */
- ResetRegPool(cUnit);
- ResetDefTracking(cUnit);
+ ResetRegPool(cu);
+ ResetDefTracking(cu);
- ClobberAllRegs(cUnit);
+ ClobberAllRegs(cu);
- if (bb->blockType == kEntryBlock) {
- int startVReg = cUnit->numDalvikRegisters - cUnit->numIns;
- GenEntrySequence(cUnit, &cUnit->regLocation[startVReg],
- cUnit->regLocation[cUnit->methodSReg]);
- } else if (bb->blockType == kExitBlock) {
- GenExitSequence(cUnit);
+ if (bb->block_type == kEntryBlock) {
+ int start_vreg = cu->num_dalvik_registers - cu->num_ins;
+ GenEntrySequence(cu, &cu->reg_location[start_vreg],
+ cu->reg_location[cu->method_sreg]);
+ } else if (bb->block_type == kExitBlock) {
+ GenExitSequence(cu);
}
- for (mir = bb->firstMIRInsn; mir; mir = mir->next) {
- ResetRegPool(cUnit);
- if (cUnit->disableOpt & (1 << kTrackLiveTemps)) {
- ClobberAllRegs(cUnit);
+ for (mir = bb->first_mir_insn; mir; mir = mir->next) {
+ ResetRegPool(cu);
+ if (cu->disable_opt & (1 << kTrackLiveTemps)) {
+ ClobberAllRegs(cu);
}
- if (cUnit->disableOpt & (1 << kSuppressLoads)) {
- ResetDefTracking(cUnit);
+ if (cu->disable_opt & (1 << kSuppressLoads)) {
+ ResetDefTracking(cu);
}
#ifndef NDEBUG
/* Reset temp tracking sanity check */
- cUnit->liveSReg = INVALID_SREG;
+ cu->live_sreg = INVALID_SREG;
#endif
- cUnit->currentDalvikOffset = mir->offset;
+ cu->current_dalvik_offset = mir->offset;
int opcode = mir->dalvikInsn.opcode;
- LIR* boundaryLIR;
+ LIR* boundary_lir;
/* Mark the beginning of a Dalvik instruction for line tracking */
- char* instStr = cUnit->printMe ?
- GetDalvikDisassembly(cUnit, mir->dalvikInsn, "") : NULL;
- boundaryLIR = MarkBoundary(cUnit, mir->offset, instStr);
+ char* inst_str = cu->verbose ?
+ GetDalvikDisassembly(cu, mir->dalvikInsn, "") : NULL;
+ boundary_lir = MarkBoundary(cu, mir->offset, inst_str);
/* Remember the first LIR for this block */
- if (headLIR == NULL) {
- headLIR = boundaryLIR;
- /* Set the first boundaryLIR as a scheduling barrier */
- headLIR->defMask = ENCODE_ALL;
+ if (head_lir == NULL) {
+ head_lir = boundary_lir;
+ /* Set the first boundary_lir as a scheduling barrier */
+ head_lir->def_mask = ENCODE_ALL;
}
/* Don't generate the SSA annotation unless verbose mode is on */
- if (cUnit->printMe && mir->ssaRep) {
- char* ssaString = GetSSAString(cUnit, mir->ssaRep);
- NewLIR1(cUnit, kPseudoSSARep, reinterpret_cast<uintptr_t>(ssaString));
+ if (cu->verbose && mir->ssa_rep) {
+ char* ssa_string = GetSSAString(cu, mir->ssa_rep);
+ NewLIR1(cu, kPseudoSSARep, reinterpret_cast<uintptr_t>(ssa_string));
}
if (opcode == kMirOpCheck) {
// Combine check and work halves of throwing instruction.
- MIR* workHalf = mir->meta.throwInsn;
- mir->dalvikInsn.opcode = workHalf->dalvikInsn.opcode;
- opcode = workHalf->dalvikInsn.opcode;
- SSARepresentation* ssaRep = workHalf->ssaRep;
- workHalf->ssaRep = mir->ssaRep;
- mir->ssaRep = ssaRep;
- workHalf->dalvikInsn.opcode = static_cast<Instruction::Code>(kMirOpNop);
+ MIR* work_half = mir->meta.throw_insn;
+ mir->dalvikInsn.opcode = work_half->dalvikInsn.opcode;
+ opcode = work_half->dalvikInsn.opcode;
+ SSARepresentation* ssa_rep = work_half->ssa_rep;
+ work_half->ssa_rep = mir->ssa_rep;
+ mir->ssa_rep = ssa_rep;
+ work_half->dalvikInsn.opcode = static_cast<Instruction::Code>(kMirOpNop);
}
if (opcode >= kMirOpFirst) {
- HandleExtendedMethodMIR(cUnit, bb, mir);
+ HandleExtendedMethodMIR(cu, bb, mir);
continue;
}
- bool notHandled = CompileDalvikInstruction(cUnit, mir, bb, labelList);
- if (notHandled) {
+ bool not_handled = CompileDalvikInstruction(cu, mir, bb, label_list);
+ if (not_handled) {
LOG(FATAL) << StringPrintf("%#06x: Opcode %#x (%s)",
mir->offset, opcode,
Instruction::Name(mir->dalvikInsn.opcode));
}
}
- if (headLIR) {
+ if (head_lir) {
/*
* Eliminate redundant loads/stores and delay stores into later
* slots
*/
- ApplyLocalOptimizations(cUnit, headLIR, cUnit->lastLIRInsn);
+ ApplyLocalOptimizations(cu, head_lir, cu->last_lir_insn);
/*
* Generate an unconditional branch to the fallthrough block.
*/
- if (bb->fallThrough) {
- OpUnconditionalBranch(cUnit, &labelList[bb->fallThrough->id]);
+ if (bb->fall_through) {
+ OpUnconditionalBranch(cu, &label_list[bb->fall_through->id]);
}
}
return false;
}
-void SpecialMIR2LIR(CompilationUnit* cUnit, SpecialCaseHandler specialCase)
+void SpecialMIR2LIR(CompilationUnit* cu, SpecialCaseHandler special_case)
{
/* Find the first DalvikByteCode block */
- int numReachableBlocks = cUnit->numReachableBlocks;
- const GrowableList *blockList = &cUnit->blockList;
+ int num_reachable_blocks = cu->num_reachable_blocks;
+ const GrowableList *block_list = &cu->block_list;
BasicBlock*bb = NULL;
- for (int idx = 0; idx < numReachableBlocks; idx++) {
- int dfsIndex = cUnit->dfsOrder.elemList[idx];
- bb = reinterpret_cast<BasicBlock*>(GrowableListGetElement(blockList, dfsIndex));
- if (bb->blockType == kDalvikByteCode) {
+ for (int idx = 0; idx < num_reachable_blocks; idx++) {
+ int dfs_index = cu->dfs_order.elem_list[idx];
+ bb = reinterpret_cast<BasicBlock*>(GrowableListGetElement(block_list, dfs_index));
+ if (bb->block_type == kDalvikByteCode) {
break;
}
}
if (bb == NULL) {
return;
}
- DCHECK_EQ(bb->startOffset, 0);
- DCHECK(bb->firstMIRInsn != NULL);
+ DCHECK_EQ(bb->start_offset, 0);
+ DCHECK(bb->first_mir_insn != NULL);
/* Get the first instruction */
- MIR* mir = bb->firstMIRInsn;
+ MIR* mir = bb->first_mir_insn;
/* Free temp registers and reset redundant store tracking */
- ResetRegPool(cUnit);
- ResetDefTracking(cUnit);
- ClobberAllRegs(cUnit);
+ ResetRegPool(cu);
+ ResetDefTracking(cu);
+ ClobberAllRegs(cu);
- GenSpecialCase(cUnit, bb, mir, specialCase);
+ GenSpecialCase(cu, bb, mir, special_case);
}
-void MethodMIR2LIR(CompilationUnit* cUnit)
+void MethodMIR2LIR(CompilationUnit* cu)
{
/* Used to hold the labels of each block */
- cUnit->blockLabelList =
- static_cast<LIR*>(NewMem(cUnit, sizeof(LIR) * cUnit->numBlocks, true, kAllocLIR));
+ cu->block_label_list =
+ static_cast<LIR*>(NewMem(cu, sizeof(LIR) * cu->num_blocks, true, kAllocLIR));
- DataFlowAnalysisDispatcher(cUnit, MethodBlockCodeGen,
+ DataFlowAnalysisDispatcher(cu, MethodBlockCodeGen,
kPreOrderDFSTraversal, false /* Iterative */);
- HandleSuspendLaunchPads(cUnit);
+ HandleSuspendLaunchPads(cu);
- HandleThrowLaunchPads(cUnit);
+ HandleThrowLaunchPads(cu);
- HandleIntrinsicLaunchPads(cUnit);
+ HandleIntrinsicLaunchPads(cu);
- if (!(cUnit->disableOpt & (1 << kSafeOptimizations))) {
- RemoveRedundantBranches(cUnit);
+ if (!(cu->disable_opt & (1 << kSafeOptimizations))) {
+ RemoveRedundantBranches(cu);
}
}