6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2026-04-23 22:23:00 +00:00
Code Issues Projects Releases Wiki Activity

This checkin represents some cleanup of the backend, implementing the following things:

Browse Source 
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.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@559 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner
2001-09-14 03:37:52 +00:00
parent 0811f76860
commit 0e6530ee1b
14 changed files with 1841 additions and 1890 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/CodeGen/InstrSelection/InstrSelection.cpp
+70 -90
View File
@@ -45,10 +45,7 @@ cl::Enum<enum SelectDebugLevel_t> SelectDebugLevel("dselect", cl::NoFlags,
// 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 @@ SelectInstructionsForMethod(Method* method,
//
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 @@ FoldGetElemChain(const InstructionNode* getElemInstrNode,
// 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 @@ SelectInstructionsForTree(InstrTreeNode* treeRoot, int goalnt,
//
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 @@ SelectInstructionsForTree(InstrTreeNode* treeRoot, int goalnt,
// (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
}