6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-10-20 09:24:58 +00:00
Code Issues Projects Releases Wiki Activity

Cosmetic changes only.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@946 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Vikram S. Adve 2001-10-22 13:51:09 +00:00
parent fb8c0533b4
commit 7ad1046065
2 changed files with 98 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
lib/CodeGen/InstrSelection/InstrSelection.cpp
View File

@ -22,9 +22,12 @@
#include "llvm/BasicBlock.h"
#include "llvm/Method.h"
static bool SelectInstructionsForTree(InstrTreeNode* treeRoot, int goalnt,
TargetMachine &target);
//******************** Internal Data Declarations ************************/
// Use a static vector to avoid allocating a new one per VM instruction
static MachineInstr* minstrVec[MAX_INSTR_PER_VMINSTR];
enum SelectDebugLevel_t {
Select_NoDebugInfo,
@ -42,6 +45,21 @@ cl::Enum<enum SelectDebugLevel_t> SelectDebugLevel("dselect", cl::NoFlags,
clEnumValN(Select_DebugBurgTrees, "b", "print burg trees"), 0);
//******************** Forward Function Declarations ***********************/
static bool SelectInstructionsForTree (InstrTreeNode* treeRoot,
int goalnt,
TargetMachine &target);
static void PostprocessMachineCodeForTree(InstructionNode* instrNode,
int ruleForNode,
short* nts,
TargetMachine &target);
//******************* Externally Visible Functions *************************/
//---------------------------------------------------------------------------
// Entry point for instruction selection using BURG.
@ -110,8 +128,9 @@ SelectInstructionsForMethod(Method* method, TargetMachine &target)
if (SelectDebugLevel >= Select_PrintMachineCode)
{
cout << endl << "*** Machine instructions after INSTRUCTION SELECTION" << endl;
PrintMachineInstructions(method);
cout << endl
<< "*** Machine instructions after INSTRUCTION SELECTION" << endl;
method->getMachineCode().dump();
}
return false;
@ -121,6 +140,25 @@ SelectInstructionsForMethod(Method* method, TargetMachine &target)
//*********************** Private Functions *****************************/
//---------------------------------------------------------------------------
// Function AppendMachineCodeForVMInstr
//
// Append machine instr sequence to the machine code vec for a VM instr
//---------------------------------------------------------------------------
inline void
AppendMachineCodeForVMInstr(MachineInstr** minstrVec,
unsigned int N,
Instruction* vmInstr)
{
if (N == 0)
return;
MachineCodeForVMInstr& mvec = vmInstr->getMachineInstrVec();
mvec.insert(mvec.end(), minstrVec, minstrVec+N);
}
//---------------------------------------------------------------------------
// Function PostprocessMachineCodeForTree
//
@ -128,7 +166,7 @@ SelectInstructionsForMethod(Method* method, TargetMachine &target)
// after selection for all its children has been completed.
//---------------------------------------------------------------------------
void
static void
PostprocessMachineCodeForTree(InstructionNode* instrNode,
int ruleForNode,
short* nts,
@ -170,9 +208,6 @@ 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];
// Get the rule that matches this node.
//
int ruleForNode = burm_rule(treeRoot->state, goalnt);
@ -196,15 +231,14 @@ SelectInstructionsForTree(InstrTreeNode* treeRoot, int goalnt,
{
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 (N > 0)
{
assert(N <= MAX_INSTR_PER_VMINSTR);
AppendMachineCodeForVMInstr(minstrVec,N,instrNode->getInstruction());
}
}
// Then, recursively compile the child nodes, if any.

64
lib/Target/SparcV9/InstrSelection/InstrSelection.cpp
View File

@ -22,9 +22,12 @@
#include "llvm/BasicBlock.h"
#include "llvm/Method.h"
static bool SelectInstructionsForTree(InstrTreeNode* treeRoot, int goalnt,
TargetMachine &target);
//******************** Internal Data Declarations ************************/
// Use a static vector to avoid allocating a new one per VM instruction
static MachineInstr* minstrVec[MAX_INSTR_PER_VMINSTR];
enum SelectDebugLevel_t {
Select_NoDebugInfo,
@ -42,6 +45,21 @@ cl::Enum<enum SelectDebugLevel_t> SelectDebugLevel("dselect", cl::NoFlags,
clEnumValN(Select_DebugBurgTrees, "b", "print burg trees"), 0);
//******************** Forward Function Declarations ***********************/
static bool SelectInstructionsForTree (InstrTreeNode* treeRoot,
int goalnt,
TargetMachine &target);
static void PostprocessMachineCodeForTree(InstructionNode* instrNode,
int ruleForNode,
short* nts,
TargetMachine &target);
//******************* Externally Visible Functions *************************/
//---------------------------------------------------------------------------
// Entry point for instruction selection using BURG.
@ -110,8 +128,9 @@ SelectInstructionsForMethod(Method* method, TargetMachine &target)
if (SelectDebugLevel >= Select_PrintMachineCode)
{
cout << endl << "*** Machine instructions after INSTRUCTION SELECTION" << endl;
PrintMachineInstructions(method);
cout << endl
<< "*** Machine instructions after INSTRUCTION SELECTION" << endl;
method->getMachineCode().dump();
}
return false;
@ -121,6 +140,25 @@ SelectInstructionsForMethod(Method* method, TargetMachine &target)
//*********************** Private Functions *****************************/
//---------------------------------------------------------------------------
// Function AppendMachineCodeForVMInstr
//
// Append machine instr sequence to the machine code vec for a VM instr
//---------------------------------------------------------------------------
inline void
AppendMachineCodeForVMInstr(MachineInstr** minstrVec,
unsigned int N,
Instruction* vmInstr)
{
if (N == 0)
return;
MachineCodeForVMInstr& mvec = vmInstr->getMachineInstrVec();
mvec.insert(mvec.end(), minstrVec, minstrVec+N);
}
//---------------------------------------------------------------------------
// Function PostprocessMachineCodeForTree
//
@ -128,7 +166,7 @@ SelectInstructionsForMethod(Method* method, TargetMachine &target)
// after selection for all its children has been completed.
//---------------------------------------------------------------------------
void
static void
PostprocessMachineCodeForTree(InstructionNode* instrNode,
int ruleForNode,
short* nts,
@ -170,9 +208,6 @@ 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];
// Get the rule that matches this node.
//
int ruleForNode = burm_rule(treeRoot->state, goalnt);
@ -196,15 +231,14 @@ SelectInstructionsForTree(InstrTreeNode* treeRoot, int goalnt,
{
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 (N > 0)
{
assert(N <= MAX_INSTR_PER_VMINSTR);
AppendMachineCodeForVMInstr(minstrVec,N,instrNode->getInstruction());
}
}
// Then, recursively compile the child nodes, if any.