RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-25 20:23:11 +01:00
Code Issues Projects Releases Wiki Activity

Removal of the redundant CompileContext wrapper

Browse Source 
llvm-svn: 274
This commit is contained in:
Chris Lattner 2001-07-23 03:09:03 +00:00
parent 90f8ecfda4
commit d73669f4c6
5 changed files with 36 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
include/llvm/CodeGen/InstrSelection.h
View File

@ -14,13 +14,13 @@
#include "llvm/Instruction.h"
#include <vector>
class CompileContext;
class Method;
class InstrForest;
class MachineInstr;
class InstructionNode;
class TmpInstruction;
class ConstPoolVal;
class TargetMachine;
//---------------------------------------------------------------------------
// GLOBAL data and an external function that must be implemented
@ -32,7 +32,7 @@ const unsigned MAX_INSTR_PER_VMINSTR = 8;
extern unsigned GetInstructionsByRule (InstructionNode* subtreeRoot,
int ruleForNode,
short* nts,
CompileContext& ccontext,
TargetMachine &Target,
MachineInstr** minstrVec);
extern bool ThisIsAChainRule (int eruleno);
@ -51,7 +51,7 @@ extern bool ThisIsAChainRule (int eruleno);
//---------------------------------------------------------------------------
bool SelectInstructionsForMethod (Method* method,
CompileContext& ccontext);
TargetMachine &Target);
// Debugging function to print the generated instructions

35
include/llvm/LLC/CompileContext.h
View File

@ -1,35 +0,0 @@
// $Id$ -*-c++-*-
//***************************************************************************
// class CompileContext
//
// Purpose:
// Holds the common option and target information for a compilation run.
//
// History:
// 07/15/01 - vadve - Created
//
//**************************************************************************/
#ifndef LLVM_LLC_COMPILECONTEXT_H
#define LLVM_LLC_COMPILECONTEXT_H
#include "llvm/Support/Unique.h"
class TargetMachine;
//---------------------------------------------------------------------------
// class CompileContext
//---------------------------------------------------------------------------
class CompileContext: public Unique {
private:
TargetMachine* targetMachine;
public:
CompileContext(TargetMachine *Target) : targetMachine(Target) {}
~CompileContext();
const TargetMachine& getTarget () const { return *targetMachine; }
TargetMachine& getTarget () { return *targetMachine; }
};
#endif

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

@ -16,7 +16,6 @@
#include "llvm/Type.h"
#include "llvm/iMemory.h"
#include "llvm/Instruction.h"
#include "llvm/LLC/CompileContext.h"
#include "llvm/CodeGen/MachineInstr.h"
#include "llvm/Tools/CommandLine.h"
@ -36,7 +35,7 @@ cl::Enum<enum DebugLev> DebugLevel("debug_select", cl::NoFlags, // cl::Hidden
//************************* Forward Declarations ***************************/
static bool SelectInstructionsForTree(BasicTreeNode* treeRoot, int goalnt,
CompileContext& ccontext);
TargetMachine &Target);
//******************* Externally Visible Functions *************************/
@ -47,7 +46,7 @@ static bool SelectInstructionsForTree(BasicTreeNode* treeRoot, int goalnt,
// Returns true if instruction selection failed, false otherwise.
//---------------------------------------------------------------------------
bool SelectInstructionsForMethod(Method* method, CompileContext& ccontext) {
bool SelectInstructionsForMethod(Method* method, TargetMachine &Target) {
bool failed = false;
InstrForest instrForest;
@ -77,7 +76,7 @@ bool SelectInstructionsForMethod(Method* method, CompileContext& ccontext) {
}
// Then recursively walk the tree to select instructions
if (SelectInstructionsForTree(basicNode, /*goalnt*/1, ccontext))
if (SelectInstructionsForTree(basicNode, /*goalnt*/1, Target))
{
failed = true;
break;
@ -191,7 +190,7 @@ void PrintMachineInstructions(Method* method) {
bool
SelectInstructionsForTree(BasicTreeNode* treeRoot,
int goalnt,
CompileContext& ccontext)
TargetMachine &Target)
{
// Use a static vector to avoid allocating a new one per VM instruction
static MachineInstr* minstrVec[MAX_INSTR_PER_VMINSTR];
@ -220,7 +219,7 @@ SelectInstructionsForTree(BasicTreeNode* treeRoot,
InstructionNode* instrNode = (InstructionNode*) MainTreeNode(treeRoot);
assert(instrNode->getNodeType() == InstrTreeNode::NTInstructionNode);
unsigned N = GetInstructionsByRule(instrNode, ruleForNode, nts, ccontext,
unsigned N = GetInstructionsByRule(instrNode, ruleForNode, nts, Target,
minstrVec);
assert(N <= MAX_INSTR_PER_VMINSTR);
for (unsigned i=0; i < N; i++)
@ -260,8 +259,7 @@ SelectInstructionsForTree(BasicTreeNode* treeRoot,
if (nodeType == InstrTreeNode::NTVRegListNode ||
nodeType == InstrTreeNode::NTInstructionNode)
{
bool failed= SelectInstructionsForTree(kids[i], nts[i],ccontext);
if (failed)
if (SelectInstructionsForTree(kids[i], nts[i], Target))
return true; // failure
}
}

50
lib/CodeGen/TargetMachine/Sparc/SparcInstrSelection.cpp
View File

@ -9,8 +9,6 @@
// 7/02/01 - Vikram Adve - Created
//***************************************************************************
//*************************** User Include Files ***************************/
#include "llvm/Type.h"
#include "llvm/DerivedTypes.h"
#include "llvm/SymbolTable.h"
@ -23,7 +21,6 @@
#include "llvm/BasicBlock.h"
#include "llvm/Method.h"
#include "llvm/ConstPoolVals.h"
#include "llvm/LLC/CompileContext.h"
#include "llvm/CodeGen/Sparc.h"
#include "llvm/CodeGen/MachineInstr.h"
#include "llvm/CodeGen/InstrForest.h"
@ -148,7 +145,7 @@ unsigned
GetInstructionsByRule(InstructionNode* subtreeRoot,
int ruleForNode,
short* nts,
CompileContext& ccontext,
TargetMachine &Target,
MachineInstr** mvec)
{
int numInstr = 1; // initialize for common case
@ -183,7 +180,7 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
case 3: // stmt: Store(reg,reg)
case 4: // stmt: Store(reg,ptrreg)
mvec[0] = new MachineInstr(ChooseStoreInstruction(subtreeRoot->leftChild()->getValue()->getType()));
SetOperandsForMemInstr(mvec[0], subtreeRoot, ccontext.getTarget());
SetOperandsForMemInstr(mvec[0], subtreeRoot, Target);
break;
case 5: // stmt: BrUncond
@ -307,7 +304,7 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
else
{
mvec[0] =new MachineInstr(ChooseConvertToIntInstr(subtreeRoot,opType));
Set2OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
Set2OperandsFromInstr(mvec[0], subtreeRoot, Target);
}
break;
@ -329,7 +326,7 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
{
opType = subtreeRoot->leftChild()->getValue()->getType();
mvec[0] = new MachineInstr(ChooseConvertToFloatInstr(subtreeRoot, opType));
Set2OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
Set2OperandsFromInstr(mvec[0], subtreeRoot, Target);
}
break;
@ -340,12 +337,12 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
case 33: // reg: Add(reg, reg)
mvec[0] = new MachineInstr(ChooseAddInstruction(subtreeRoot));
Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
Set3OperandsFromInstr(mvec[0], subtreeRoot, Target);
break;
case 34: // reg: Sub(reg, reg)
mvec[0] = new MachineInstr(ChooseSubInstruction(subtreeRoot));
Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
Set3OperandsFromInstr(mvec[0], subtreeRoot, Target);
break;
case 135: // reg: Mul(todouble, todouble)
@ -354,12 +351,12 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
case 35: // reg: Mul(reg, reg)
mvec[0] = new MachineInstr(ChooseMulInstruction(subtreeRoot, checkCast));
Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
Set3OperandsFromInstr(mvec[0], subtreeRoot, Target);
break;
case 36: // reg: Div(reg, reg)
mvec[0] = new MachineInstr(ChooseDivInstruction(subtreeRoot));
Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
Set3OperandsFromInstr(mvec[0], subtreeRoot, Target);
break;
case 37: // reg: Rem(reg, reg)
@ -368,32 +365,32 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
case 38: // reg: And(reg, reg)
mvec[0] = new MachineInstr(AND);
Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
Set3OperandsFromInstr(mvec[0], subtreeRoot, Target);
break;
case 138: // reg: And(reg, not)
mvec[0] = new MachineInstr(ANDN);
Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
Set3OperandsFromInstr(mvec[0], subtreeRoot, Target);
break;
case 39: // reg: Or(reg, reg)
mvec[0] = new MachineInstr(ORN);
Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
Set3OperandsFromInstr(mvec[0], subtreeRoot, Target);
break;
case 139: // reg: Or(reg, not)
mvec[0] = new MachineInstr(ORN);
Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
Set3OperandsFromInstr(mvec[0], subtreeRoot, Target);
break;
case 40: // reg: Xor(reg, reg)
mvec[0] = new MachineInstr(XOR);
Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
Set3OperandsFromInstr(mvec[0], subtreeRoot, Target);
break;
case 140: // reg: Xor(reg, not)
mvec[0] = new MachineInstr(XNOR);
Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
Set3OperandsFromInstr(mvec[0], subtreeRoot, Target);
break;
case 41: // boolconst: SetCC(reg, Constant)
@ -430,7 +427,7 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
{
// integer condition: destination should be %g0
mvec[0] = new MachineInstr(SUBcc);
Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget(),
Set3OperandsFromInstr(mvec[0], subtreeRoot, Target,
/*canDiscardResult*/ true);
}
else
@ -456,7 +453,7 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
case 53: // reg: LoadIdx(reg,reg)
case 54: // reg: LoadIdx(ptrreg,reg)
mvec[0] = new MachineInstr(ChooseLoadInstruction(subtreeRoot->getValue()->getType()));
SetOperandsForMemInstr(mvec[0], subtreeRoot, ccontext.getTarget());
SetOperandsForMemInstr(mvec[0], subtreeRoot, Target);
break;
case 55: // reg: GetElemPtr(reg)
@ -476,7 +473,7 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
}
// else in all other cases we need to a separate ADD instruction
mvec[0] = new MachineInstr(ADD);
SetOperandsForMemInstr(mvec[0], subtreeRoot, ccontext.getTarget());
SetOperandsForMemInstr(mvec[0], subtreeRoot, Target);
break;
case 57: // reg: Alloca: Implement as 2 instructions:
@ -485,8 +482,7 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
Instruction* instr = subtreeRoot->getInstruction();
const PointerType* instrType = (const PointerType*) instr->getType();
assert(instrType->isPointerType());
int tsize = (int) ccontext.getTarget().findOptimalStorageSize(
instrType->getValueType());
int tsize = (int) Target.findOptimalStorageSize(instrType->getValueType());
if (tsize == 0)
{
numInstr = 0;
@ -528,7 +524,7 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
instrType->getValueType()->isArrayType());
const Type* eltType =
((ArrayType*) instrType->getValueType())->getElementType();
int tsize = (int) ccontext.getTarget().findOptimalStorageSize(eltType);
int tsize = (int) Target.findOptimalStorageSize(eltType);
if (tsize == 0)
{
@ -600,7 +596,7 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
opType = subtreeRoot->leftChild()->getValue()->getType();
assert(opType->isIntegral() || opType == Type::BoolTy);
mvec[0] = new MachineInstr((opType == Type::LongTy)? SLLX : SLL);
Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
Set3OperandsFromInstr(mvec[0], subtreeRoot, Target);
break;
case 63: // reg: Shr(reg, reg)
@ -609,7 +605,7 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
mvec[0] = new MachineInstr((opType->isSigned()
? ((opType == Type::LongTy)? SRAX : SRA)
: ((opType == Type::LongTy)? SRLX : SRL)));
Set3OperandsFromInstr(mvec[0], subtreeRoot, ccontext.getTarget());
Set3OperandsFromInstr(mvec[0], subtreeRoot, Target);
break;
case 71: // reg: VReg
@ -642,7 +638,7 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
&& "A chain rule should have only one RHS non-terminal!");
nextRule = burm_rule(subtreeRoot->getBasicNode()->state, nts[0]);
nts = burm_nts[nextRule];
numInstr = GetInstructionsByRule(subtreeRoot, nextRule, nts,ccontext,mvec);
numInstr = GetInstructionsByRule(subtreeRoot, nextRule, nts,Target,mvec);
break;
default:
@ -651,7 +647,7 @@ GetInstructionsByRule(InstructionNode* subtreeRoot,
}
numInstr =
FixConstantOperands(subtreeRoot, mvec, numInstr, ccontext.getTarget());
FixConstantOperands(subtreeRoot, mvec, numInstr, Target);
return numInstr;
}

12
tools/llc/llc.cpp
View File

@ -16,17 +16,13 @@
#include "llvm/Bytecode/Reader.h"
#include "llvm/Bytecode/Writer.h"
#include "llvm/CodeGen/InstrSelection.h"
#include "llvm/LLC/CompileContext.h"
#include "llvm/CodeGen/Sparc.h"
#include "llvm/Tools/CommandLine.h"
cl::String InputFilename ("", "Input filename", cl::NoFlags, "");
cl::String OutputFilename("o", "Output filename", cl::NoFlags, "");
CompileContext::~CompileContext() { delete targetMachine; }
static bool CompileModule(Module *module, CompileContext& ccontext) {
static bool CompileModule(Module *module, TargetMachine &Target) {
bool failed = false;
for (Module::MethodListType::const_iterator
@ -36,7 +32,7 @@ static bool CompileModule(Module *module, CompileContext& ccontext) {
{
Method* method = *methodIter;
if (SelectInstructionsForMethod(method, ccontext))
if (SelectInstructionsForMethod(method, Target))
{
failed = true;
cerr << "Instruction selection failed for method "
@ -56,7 +52,7 @@ static bool CompileModule(Module *module, CompileContext& ccontext) {
int main(int argc, char** argv) {
cl::ParseCommandLineOptions(argc, argv, " llvm system compiler\n");
CompileContext compileContext(new UltraSparc());
UltraSparc Target;
Module *module = ParseBytecodeFile(InputFilename.getValue());
if (module == 0) {
@ -64,7 +60,7 @@ int main(int argc, char** argv) {
return 1;
}
bool failure = CompileModule(module, compileContext);
bool failure = CompileModule(module, Target);
if (failure) {
cerr << "Error compiling "