This checkin represents some cleanup of the backend, implementing the following things:
1. The TargetMachine structure is free to decide the process a particular target uses to generate code.
2. All of the gooee details of the sparc backend are now localized in the lib/CodeGen/TargetMAchine/Sparc directory. The Sparc.h file that is globally visible is just a stub.
3. The Sparc.h file that esxists now will dissapear entirely someday when we have multiple backends chosen by a factory of some sort.
llvm-svn: 559
diff --git a/llvm/lib/CodeGen/InstrSelection/InstrSelection.cpp b/llvm/lib/CodeGen/InstrSelection/InstrSelection.cpp
index b77b5a8..7153b3c 100644
--- a/llvm/lib/CodeGen/InstrSelection/InstrSelection.cpp
+++ b/llvm/lib/CodeGen/InstrSelection/InstrSelection.cpp
@@ -45,10 +45,7 @@
// Returns true if instruction selection failed, false otherwise.
//---------------------------------------------------------------------------
-bool
-SelectInstructionsForMethod(Method* method,
- TargetMachine &Target)
-{
+bool SelectInstructionsForMethod(Method* method, TargetMachine &Target) {
bool failed = false;
//
@@ -69,49 +66,42 @@
//
const hash_set<InstructionNode*> &treeRoots = instrForest.getRootSet();
for (hash_set<InstructionNode*>::const_iterator
- treeRootIter = treeRoots.begin();
- treeRootIter != treeRoots.end();
- ++treeRootIter)
- {
- InstrTreeNode* basicNode = *treeRootIter;
+ treeRootIter = treeRoots.begin(); treeRootIter != treeRoots.end();
+ ++treeRootIter) {
+ InstrTreeNode* basicNode = *treeRootIter;
- // Invoke BURM to label each tree node with a state
- (void) burm_label(basicNode);
+ // Invoke BURM to label each tree node with a state
+ burm_label(basicNode);
- if (SelectDebugLevel >= Select_DebugBurgTrees)
- {
- printcover(basicNode, 1, 0);
- cerr << "\nCover cost == " << treecost(basicNode, 1, 0) << "\n\n";
- printMatches(basicNode);
- }
-
- // Then recursively walk the tree to select instructions
- if (SelectInstructionsForTree(basicNode, /*goalnt*/1, Target))
- {
- failed = true;
- break;
- }
+ if (SelectDebugLevel >= Select_DebugBurgTrees) {
+ printcover(basicNode, 1, 0);
+ cerr << "\nCover cost == " << treecost(basicNode, 1, 0) << "\n\n";
+ printMatches(basicNode);
}
+
+ // Then recursively walk the tree to select instructions
+ if (SelectInstructionsForTree(basicNode, /*goalnt*/1, Target)) {
+ failed = true;
+ break;
+ }
+ }
//
// Record instructions in the vector for each basic block
//
- for (Method::iterator BI = method->begin(); BI != method->end(); ++BI)
- {
- MachineCodeForBasicBlock& bbMvec = (*BI)->getMachineInstrVec();
- for (BasicBlock::iterator II = (*BI)->begin(); II != (*BI)->end(); ++II)
- {
- MachineCodeForVMInstr& mvec = (*II)->getMachineInstrVec();
- for (unsigned i=0; i < mvec.size(); i++)
- bbMvec.push_back(mvec[i]);
- }
+ for (Method::iterator BI = method->begin(); BI != method->end(); ++BI) {
+ MachineCodeForBasicBlock& bbMvec = (*BI)->getMachineInstrVec();
+ for (BasicBlock::iterator II = (*BI)->begin(); II != (*BI)->end(); ++II) {
+ MachineCodeForVMInstr& mvec = (*II)->getMachineInstrVec();
+ for (unsigned i=0; i < mvec.size(); i++)
+ bbMvec.push_back(mvec[i]);
}
+ }
- if (SelectDebugLevel >= Select_PrintMachineCode)
- {
- cout << endl << "*** Machine instructions after INSTRUCTION SELECTION" << endl;
- PrintMachineInstructions(method);
- }
+ if (SelectDebugLevel >= Select_PrintMachineCode) {
+ cout << endl << "*** Machine instructions after INSTRUCTION SELECTION" << endl;
+ PrintMachineInstructions(method);
+ }
return false;
}
@@ -177,10 +167,8 @@
// may be used by multiple instructions).
//---------------------------------------------------------------------------
-bool
-SelectInstructionsForTree(InstrTreeNode* treeRoot, int goalnt,
- TargetMachine &Target)
-{
+bool SelectInstructionsForTree(InstrTreeNode* treeRoot, int goalnt,
+ TargetMachine &Target) {
// Use a static vector to avoid allocating a new one per VM instruction
static MachineInstr* minstrVec[MAX_INSTR_PER_VMINSTR];
@@ -188,11 +176,10 @@
//
int ruleForNode = burm_rule(treeRoot->state, goalnt);
- if (ruleForNode == 0)
- {
- cerr << "Could not match instruction tree for instr selection" << endl;
- return true;
- }
+ if (ruleForNode == 0) {
+ cerr << "Could not match instruction tree for instr selection" << endl;
+ return true;
+ }
// Get this rule's non-terminals and the corresponding child nodes (if any)
//
@@ -203,55 +190,48 @@
// (If this is a list node, not an instruction, then skip this step).
// This function is specific to the target architecture.
//
- if (treeRoot->opLabel != VRegListOp)
- {
- InstructionNode* instrNode = (InstructionNode*)treeRoot;
- assert(instrNode->getNodeType() == InstrTreeNode::NTInstructionNode);
-
- unsigned N = GetInstructionsByRule(instrNode, ruleForNode, nts, Target,
- minstrVec);
- assert(N <= MAX_INSTR_PER_VMINSTR);
- for (unsigned i=0; i < N; i++)
- {
- assert(minstrVec[i] != NULL);
- instrNode->getInstruction()->addMachineInstruction(minstrVec[i]);
- }
+ if (treeRoot->opLabel != VRegListOp) {
+ InstructionNode* instrNode = (InstructionNode*)treeRoot;
+ assert(instrNode->getNodeType() == InstrTreeNode::NTInstructionNode);
+
+ unsigned N = GetInstructionsByRule(instrNode, ruleForNode, nts, Target,
+ minstrVec);
+ assert(N <= MAX_INSTR_PER_VMINSTR);
+ for (unsigned i=0; i < N; i++) {
+ assert(minstrVec[i] != NULL);
+ instrNode->getInstruction()->addMachineInstruction(minstrVec[i]);
}
+ }
// Then, recursively compile the child nodes, if any.
//
- if (nts[0])
- { // i.e., there is at least one kid
-
- InstrTreeNode* kids[2];
- int currentRule = ruleForNode;
+ if (nts[0]) { // i.e., there is at least one kid
+ InstrTreeNode* kids[2];
+ int currentRule = ruleForNode;
+ burm_kids(treeRoot, currentRule, kids);
+
+ // First skip over any chain rules so that we don't visit
+ // the current node again.
+ //
+ while (ThisIsAChainRule(currentRule)) {
+ currentRule = burm_rule(treeRoot->state, nts[0]);
+ nts = burm_nts[currentRule];
burm_kids(treeRoot, currentRule, kids);
-
- // First skip over any chain rules so that we don't visit
- // the current node again.
- //
- while (ThisIsAChainRule(currentRule))
- {
- currentRule = burm_rule(treeRoot->state, nts[0]);
- nts = burm_nts[currentRule];
- burm_kids(treeRoot, currentRule, kids);
- }
-
- // Now we have the first non-chain rule so we have found
- // the actual child nodes. Recursively compile them.
- //
- for (int i = 0; nts[i]; i++)
- {
- assert(i < 2);
- InstrTreeNode::InstrTreeNodeType nodeType = kids[i]->getNodeType();
- if (nodeType == InstrTreeNode::NTVRegListNode ||
- nodeType == InstrTreeNode::NTInstructionNode)
- {
- if (SelectInstructionsForTree(kids[i], nts[i], Target))
- return true; // failure
- }
- }
}
+
+ // Now we have the first non-chain rule so we have found
+ // the actual child nodes. Recursively compile them.
+ //
+ for (int i = 0; nts[i]; i++) {
+ assert(i < 2);
+ InstrTreeNode::InstrTreeNodeType nodeType = kids[i]->getNodeType();
+ if (nodeType == InstrTreeNode::NTVRegListNode ||
+ nodeType == InstrTreeNode::NTInstructionNode) {
+ if (SelectInstructionsForTree(kids[i], nts[i], Target))
+ return true; // failure
+ }
+ }
+ }
return false; // success
}