More target-independence
Continuing to move target-specific code from the Arm
code generator into the independent realm. This will be
done in multiple small steps.
In this CL, the focus is on unifying the LIR data structure and
various enums that don't really need to be target specific. Also
creates two new shared source files: GenCommon.cc (to hold
top-level code generation functions) and GenInvoke.cc (which
is likely to be shared only by the Arm and Mips targets).
Also added is a makefile hack to build for Mips (which we'll
eventually remove when the compiler support multiple targets
via the command line) and various minor cleanups.
Overall, this CL moves more than 3,000 lines of code from
target dependent to target independent.
Change-Id: I431ca4ae728100ed7d0e9d83a966a3f789f731b1
diff --git a/src/compiler/codegen/LocalOptimizations.cc b/src/compiler/codegen/LocalOptimizations.cc
index cc276f2..19b41e7 100644
--- a/src/compiler/codegen/LocalOptimizations.cc
+++ b/src/compiler/codegen/LocalOptimizations.cc
@@ -27,7 +27,7 @@
#define LDLD_DISTANCE 4
#define LD_LATENCY 2
-STATIC inline bool isDalvikRegisterClobbered(TGT_LIR* lir1, TGT_LIR* lir2)
+inline bool isDalvikRegisterClobbered(LIR* lir1, LIR* lir2)
{
int reg1Lo = DECODE_ALIAS_INFO_REG(lir1->aliasInfo);
int reg1Hi = reg1Lo + DECODE_ALIAS_INFO_WIDE(lir1->aliasInfo);
@@ -38,11 +38,11 @@
}
/* Convert a more expensive instruction (ie load) into a move */
-STATIC void convertMemOpIntoMove(CompilationUnit* cUnit, TGT_LIR* origLIR,
- int dest, int src)
+void convertMemOpIntoMove(CompilationUnit* cUnit, LIR* origLIR, int dest,
+ int src)
{
/* Insert a move to replace the load */
- TGT_LIR* moveLIR;
+ LIR* moveLIR;
moveLIR = oatRegCopyNoInsert( cUnit, dest, src);
/*
* Insert the converted instruction after the original since the
@@ -71,11 +71,10 @@
* 1) They are must-aliases
* 2) The memory location is not written to in between
*/
-STATIC void applyLoadStoreElimination(CompilationUnit* cUnit,
- TGT_LIR* headLIR,
- TGT_LIR* tailLIR)
+void applyLoadStoreElimination(CompilationUnit* cUnit, LIR* headLIR,
+ LIR* tailLIR)
{
- TGT_LIR* thisLIR;
+ LIR* thisLIR;
if (headLIR == tailLIR) return;
@@ -93,7 +92,7 @@
int nativeRegId = thisLIR->operands[0];
bool isThisLIRLoad = EncodingMap[thisLIR->opcode].flags & IS_LOAD;
- TGT_LIR* checkLIR;
+ LIR* checkLIR;
/* Use the mem mask to determine the rough memory location */
u8 thisMemMask = (thisLIR->useMask | thisLIR->defMask) & ENCODE_MEM;
@@ -230,9 +229,9 @@
"REG CLOBBERED"));
/* Only sink store instructions */
if (sinkDistance && !isThisLIRLoad) {
- TGT_LIR* newStoreLIR =
- (TGT_LIR* ) oatNew(cUnit, sizeof(TGT_LIR), true,
- kAllocLIR);
+ LIR* newStoreLIR =
+ (LIR* ) oatNew(cUnit, sizeof(LIR), true,
+ kAllocLIR);
*newStoreLIR = *thisLIR;
/*
* Stop point found - insert *before* the checkLIR
@@ -255,16 +254,14 @@
* Perform a pass of bottom-up walk, from the second instruction in the
* superblock, to try to hoist loads to earlier slots.
*/
-STATIC void applyLoadHoisting(CompilationUnit* cUnit,
- TGT_LIR* headLIR,
- TGT_LIR* tailLIR)
+void applyLoadHoisting(CompilationUnit* cUnit, LIR* headLIR, LIR* tailLIR)
{
- TGT_LIR* thisLIR, *checkLIR;
+ LIR* thisLIR, *checkLIR;
/*
* Store the list of independent instructions that can be hoisted past.
* Will decide the best place to insert later.
*/
- TGT_LIR* prevInstList[MAX_HOIST_DISTANCE];
+ LIR* prevInstList[MAX_HOIST_DISTANCE];
/* Empty block */
if (headLIR == tailLIR) return;
@@ -373,7 +370,7 @@
if (nextSlot >= 2) {
int firstSlot = nextSlot - 2;
int slot;
- TGT_LIR* depLIR = prevInstList[nextSlot-1];
+ LIR* depLIR = prevInstList[nextSlot-1];
/* If there is ld-ld dependency, wait LDLD_DISTANCE cycles */
if (!isPseudoOpcode(depLIR->opcode) &&
(EncodingMap[depLIR->opcode].flags & IS_LOAD)) {
@@ -384,8 +381,8 @@
* when the loop is first entered.
*/
for (slot = firstSlot; slot >= 0; slot--) {
- TGT_LIR* curLIR = prevInstList[slot];
- TGT_LIR* prevLIR = prevInstList[slot+1];
+ LIR* curLIR = prevInstList[slot];
+ LIR* prevLIR = prevInstList[slot+1];
/* Check the highest instruction */
if (prevLIR->defMask == ENCODE_ALL) {
@@ -418,8 +415,8 @@
/* Found a slot to hoist to */
if (slot >= 0) {
- TGT_LIR* curLIR = prevInstList[slot];
- TGT_LIR* newLoadLIR = (TGT_LIR* ) oatNew(cUnit, sizeof(TGT_LIR),
+ LIR* curLIR = prevInstList[slot];
+ LIR* newLoadLIR = (LIR* ) oatNew(cUnit, sizeof(LIR),
true, kAllocLIR);
*newLoadLIR = *thisLIR;
/*
@@ -437,11 +434,11 @@
LIR* tailLIR)
{
if (!(cUnit->disableOpt & (1 << kLoadStoreElimination))) {
- applyLoadStoreElimination(cUnit, (TGT_LIR* ) headLIR,
- (TGT_LIR* ) tailLIR);
+ applyLoadStoreElimination(cUnit, (LIR* ) headLIR,
+ (LIR* ) tailLIR);
}
if (!(cUnit->disableOpt & (1 << kLoadHoisting))) {
- applyLoadHoisting(cUnit, (TGT_LIR* ) headLIR, (TGT_LIR* ) tailLIR);
+ applyLoadHoisting(cUnit, (LIR* ) headLIR, (LIR* ) tailLIR);
}
}