6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-07-17 20:29:31 +00:00
Code Issues Projects Releases Wiki Activity

Clean up a lot of the code I added yesterday by exposing the IntrinsicLowering

Browse Source 
implementation from the TargetMachine directly.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@10636 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2003-12-28 21:23:38 +00:00
parent 27490a6fcc
commit f70e0c216c
21 changed files with 76 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -22,7 +22,6 @@ class Function;
class FunctionPass;
class InstrForest;
class InstructionNode;
class IntrinsicLowering;
class MachineCodeForInstruction;
class MachineInstr;
class TargetMachine;
@ -40,8 +39,6 @@ extern void GetInstructionsByRule (InstructionNode* subtreeRoot,
extern bool ThisIsAChainRule (int eruleno);
//************************ Exported Functions ******************************/
//---------------------------------------------------------------------------
// Function: createInstructionSelectionPass
@ -51,12 +48,9 @@ extern bool ThisIsAChainRule (int eruleno);
// Return a pass that performs machine dependent instruction selection.
//---------------------------------------------------------------------------
FunctionPass *createInstructionSelectionPass(TargetMachine &Target,
IntrinsicLowering &IL);
FunctionPass *createInstructionSelectionPass(TargetMachine &Target);
//************************ Exported Data Types *****************************/
//---------------------------------------------------------------------------
// class TmpInstruction

2
include/llvm/CodeGen/IntrinsicLowering.h
View File

@ -33,6 +33,8 @@
#ifndef LLVM_INTRINSICLOWERING_H
#define LLVM_INTRINSICLOWERING_H
#include "llvm/Intrinsics.h"
namespace llvm {
class CallInst;

2
include/llvm/IntrinsicLowering.h
View File

@ -33,6 +33,8 @@
#ifndef LLVM_INTRINSICLOWERING_H
#define LLVM_INTRINSICLOWERING_H
#include "llvm/Intrinsics.h"
namespace llvm {
class CallInst;

20
include/llvm/Target/TargetMachine.h
View File

@ -31,6 +31,7 @@ class MRegisterInfo;
class FunctionPassManager;
class PassManager;
class Pass;
class IntrinsicLowering;
//===----------------------------------------------------------------------===//
///
@ -40,24 +41,27 @@ class Pass;
///
class TargetMachine {
const std::string Name;
const TargetData DataLayout; // Calculates type size & alignment
const TargetData DataLayout; // Calculates type size & alignment
IntrinsicLowering *IL; // Specifies how to lower intrinsic calls
TargetMachine(const TargetMachine&); // DO NOT IMPLEMENT
void operator=(const TargetMachine&); // DO NOT IMPLEMENT
protected:
TargetMachine(const std::string &name, // Can only create subclasses...
protected: // Can only create subclasses...
TargetMachine(const std::string &name, IntrinsicLowering *IL,
bool LittleEndian = false,
unsigned char PtrSize = 8, unsigned char PtrAl = 8,
unsigned char DoubleAl = 8, unsigned char FloatAl = 4,
unsigned char LongAl = 8, unsigned char IntAl = 4,
unsigned char ShortAl = 2, unsigned char ByteAl = 1)
: Name(name), DataLayout(name, LittleEndian,
PtrSize, PtrAl, DoubleAl, FloatAl, LongAl,
IntAl, ShortAl, ByteAl) {}
unsigned char ShortAl = 2, unsigned char ByteAl = 1);
public:
virtual ~TargetMachine() {}
virtual ~TargetMachine();
const std::string &getName() const { return Name; }
// getIntrinsicLowering - This method returns a reference to an
// IntrinsicLowering instance which should be used by the code generator to
// lower unknown intrinsic functions to the equivalent LLVM expansion.
IntrinsicLowering &getIntrinsicLowering() const { return *IL; }
// Interfaces to the major aspects of target machine information:
// -- Instruction opcode and operand information

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

@ -16,7 +16,6 @@
#include "llvm/CodeGen/InstrSelection.h"
#include "llvm/Function.h"
#include "llvm/Intrinsics.h"
#include "llvm/IntrinsicLowering.h"
#include "llvm/iPHINode.h"
#include "llvm/iOther.h"
@ -68,7 +67,6 @@ namespace {
//
class InstructionSelection : public FunctionPass {
TargetMachine &Target;
IntrinsicLowering &IL;
void InsertCodeForPhis(Function &F);
void InsertPhiElimInstructions(BasicBlock *BB,
const std::vector<MachineInstr*>& CpVec);
@ -76,8 +74,7 @@ namespace {
void PostprocessMachineCodeForTree(InstructionNode* instrNode,
int ruleForNode, short* nts);
public:
InstructionSelection(TargetMachine &TM, IntrinsicLowering &il)
: Target(TM), IL(il) {}
InstructionSelection(TargetMachine &TM) : Target(TM) {}
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
AU.setPreservesCFG();
@ -145,7 +142,7 @@ bool InstructionSelection::runOnFunction(Function &F) {
default:
// All other intrinsic calls we must lower.
Instruction *Before = CI->getPrev();
IL.LowerIntrinsicCall(CI);
Target.getIntrinsicLowering().LowerIntrinsicCall(CI);
if (Before) { // Move iterator to instruction after call
I = Before; ++I;
} else {
@ -415,7 +412,6 @@ InstructionSelection::PostprocessMachineCodeForTree(InstructionNode* instrNode,
// createInstructionSelectionPass - Public entrypoint for instruction selection
// and this file as a whole...
//
FunctionPass *llvm::createInstructionSelectionPass(TargetMachine &T,
IntrinsicLowering &IL) {
return new InstructionSelection(T, IL);
FunctionPass *llvm::createInstructionSelectionPass(TargetMachine &TM) {
return new InstructionSelection(TM);
}

1
lib/CodeGen/IntrinsicLowering.cpp
View File

@ -13,7 +13,6 @@
#include "llvm/IntrinsicLowering.h"
#include "llvm/Constant.h"
#include "llvm/Intrinsics.h"
#include "llvm/Module.h"
#include "llvm/Type.h"
#include "llvm/iOther.h"

1
lib/ExecutionEngine/Interpreter/Execution.cpp
View File

@ -17,7 +17,6 @@
#include "llvm/DerivedTypes.h"
#include "llvm/Instructions.h"
#include "llvm/IntrinsicLowering.h"
#include "llvm/Intrinsics.h"
#include "llvm/Support/GetElementPtrTypeIterator.h"
#include "Support/Statistic.h"
#include "Support/Debug.h"

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

@ -16,7 +16,6 @@
#include "llvm/CodeGen/InstrSelection.h"
#include "llvm/Function.h"
#include "llvm/Intrinsics.h"
#include "llvm/IntrinsicLowering.h"
#include "llvm/iPHINode.h"
#include "llvm/iOther.h"
@ -68,7 +67,6 @@ namespace {
//
class InstructionSelection : public FunctionPass {
TargetMachine &Target;
IntrinsicLowering &IL;
void InsertCodeForPhis(Function &F);
void InsertPhiElimInstructions(BasicBlock *BB,
const std::vector<MachineInstr*>& CpVec);
@ -76,8 +74,7 @@ namespace {
void PostprocessMachineCodeForTree(InstructionNode* instrNode,
int ruleForNode, short* nts);
public:
InstructionSelection(TargetMachine &TM, IntrinsicLowering &il)
: Target(TM), IL(il) {}
InstructionSelection(TargetMachine &TM) : Target(TM) {}
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
AU.setPreservesCFG();
@ -145,7 +142,7 @@ bool InstructionSelection::runOnFunction(Function &F) {
default:
// All other intrinsic calls we must lower.
Instruction *Before = CI->getPrev();
IL.LowerIntrinsicCall(CI);
Target.getIntrinsicLowering().LowerIntrinsicCall(CI);
if (Before) { // Move iterator to instruction after call
I = Before; ++I;
} else {
@ -415,7 +412,6 @@ InstructionSelection::PostprocessMachineCodeForTree(InstructionNode* instrNode,
// createInstructionSelectionPass - Public entrypoint for instruction selection
// and this file as a whole...
//
FunctionPass *llvm::createInstructionSelectionPass(TargetMachine &T,
IntrinsicLowering &IL) {
return new InstructionSelection(T, IL);
FunctionPass *llvm::createInstructionSelectionPass(TargetMachine &TM) {
return new InstructionSelection(TM);
}

4
lib/Target/SparcV9/SparcV9JITInfo.h
View File

@ -18,13 +18,11 @@
namespace llvm {
class TargetMachine;
class IntrinsicLowering;
class SparcJITInfo : public TargetJITInfo {
TargetMachine &TM;
IntrinsicLowering &IL;
public:
SparcJITInfo(TargetMachine &tm, IntrinsicLowering &il) : TM(tm), IL(il) {}
SparcJITInfo(TargetMachine &tm) : TM(tm) {}
/// addPassesToJITCompile - Add passes to the specified pass manager to
/// implement a fast dynamic compiler for this target. Return true if this

13
lib/Target/SparcV9/SparcV9TargetMachine.cpp
View File

@ -116,17 +116,12 @@ FunctionPass *llvm::createSparcMachineCodeDestructionPass() {
SparcTargetMachine::SparcTargetMachine(IntrinsicLowering *il)
: TargetMachine("UltraSparc-Native", false),
IL(il ? il : new DefaultIntrinsicLowering()),
: TargetMachine("UltraSparc-Native", il, false),
schedInfo(*this),
regInfo(*this),
frameInfo(*this),
cacheInfo(*this),
jitInfo(*this, *IL) {
}
SparcTargetMachine::~SparcTargetMachine() {
delete IL;
jitInfo(*this) {
}
// addPassesToEmitAssembly - This method controls the entire code generation
@ -171,7 +166,7 @@ SparcTargetMachine::addPassesToEmitAssembly(PassManager &PM, std::ostream &Out)
PM.add(new PrintFunctionPass("Input code to instr. selection:\n",
&std::cerr));
PM.add(createInstructionSelectionPass(*this, *IL));
PM.add(createInstructionSelectionPass(*this));
if (!DisableSched)
PM.add(createInstructionSchedulingWithSSAPass(*this));
@ -238,7 +233,7 @@ void SparcJITInfo::addPassesToJITCompile(FunctionPassManager &PM) {
//PM.add(createLICMPass());
//PM.add(createGCSEPass());
PM.add(createInstructionSelectionPass(TM, IL));
PM.add(createInstructionSelectionPass(TM));
PM.add(getRegisterAllocator(TM));
PM.add(createPrologEpilogInsertionPass());

3
lib/Target/SparcV9/SparcV9TargetMachine.h
View File

@ -24,10 +24,8 @@
namespace llvm {
class PassManager;
class IntrinsicLowering;
class SparcTargetMachine : public TargetMachine {
IntrinsicLowering *IL;
SparcInstrInfo instrInfo;
SparcSchedInfo schedInfo;
SparcRegInfo regInfo;
@ -36,7 +34,6 @@ class SparcTargetMachine : public TargetMachine {
SparcJITInfo jitInfo;
public:
SparcTargetMachine(IntrinsicLowering *IL);
~SparcTargetMachine();
virtual const TargetInstrInfo &getInstrInfo() const { return instrInfo; }
virtual const TargetSchedInfo &getSchedInfo() const { return schedInfo; }

42
lib/Target/TargetMachine.cpp
View File

@ -15,20 +15,33 @@
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetCacheInfo.h"
#include "llvm/Type.h"
namespace llvm {
#include "llvm/IntrinsicLowering.h"
using namespace llvm;
//---------------------------------------------------------------------------
// class TargetMachine
//
// Purpose:
// Machine description.
//
//---------------------------------------------------------------------------
// TargetMachine Class
//
TargetMachine::TargetMachine(const std::string &name, IntrinsicLowering *il,
bool LittleEndian,
unsigned char PtrSize, unsigned char PtrAl,
unsigned char DoubleAl, unsigned char FloatAl,
unsigned char LongAl, unsigned char IntAl,
unsigned char ShortAl, unsigned char ByteAl)
: Name(name), DataLayout(name, LittleEndian,
PtrSize, PtrAl, DoubleAl, FloatAl, LongAl,
IntAl, ShortAl, ByteAl) {
IL = il ? il : new DefaultIntrinsicLowering();
}
TargetMachine::~TargetMachine() {
delete IL;
}
// function TargetMachine::findOptimalStorageSize
//
unsigned TargetMachine::findOptimalStorageSize(const Type *Ty) const {
// All integer types smaller than ints promote to 4 byte integers.
if (Ty->isIntegral() && Ty->getPrimitiveSize() < 4)
@ -39,11 +52,8 @@ unsigned TargetMachine::findOptimalStorageSize(const Type *Ty) const {
//---------------------------------------------------------------------------
// class TargetCacheInfo
//
// Purpose:
// Describes properties of the target cache architecture.
//---------------------------------------------------------------------------
// TargetCacheInfo Class
//
void TargetCacheInfo::Initialize() {
numLevels = 2;
@ -51,5 +61,3 @@ void TargetCacheInfo::Initialize() {
cacheSizes.push_back(1 << 15); cacheSizes.push_back(1 << 20);
cacheAssoc.push_back(1); cacheAssoc.push_back(4);
}
} // End llvm namespace

3
lib/Target/X86/InstSelectPattern.cpp
View File

@ -119,7 +119,6 @@ void ISel::expandCall(SelectionDAG &SD, CallInst &CI) {
/// into a machine code representation using pattern matching and a machine
/// description file.
///
FunctionPass *llvm::createX86PatternInstructionSelector(TargetMachine &TM,
IntrinsicLowering &IL) {
FunctionPass *llvm::createX86PatternInstructionSelector(TargetMachine &TM) {
return new ISel(TM);
}

12
lib/Target/X86/InstSelectSimple.cpp
View File

@ -18,7 +18,6 @@
#include "llvm/DerivedTypes.h"
#include "llvm/Function.h"
#include "llvm/Instructions.h"
#include "llvm/Intrinsics.h"
#include "llvm/IntrinsicLowering.h"
#include "llvm/Pass.h"
#include "llvm/CodeGen/MachineConstantPool.h"
@ -59,7 +58,6 @@ inline static MachineInstrBuilder BMI(MachineBasicBlock *MBB,
namespace {
struct ISel : public FunctionPass, InstVisitor<ISel> {
TargetMachine &TM;
IntrinsicLowering &IL;
MachineFunction *F; // The function we are compiling into
MachineBasicBlock *BB; // The current MBB we are compiling
int VarArgsFrameIndex; // FrameIndex for start of varargs area
@ -69,8 +67,7 @@ namespace {
// MBBMap - Mapping between LLVM BB -> Machine BB
std::map<const BasicBlock*, MachineBasicBlock*> MBBMap;
ISel(TargetMachine &tm, IntrinsicLowering &il)
: TM(tm), IL(il), F(0), BB(0) {}
ISel(TargetMachine &tm) : TM(tm), F(0), BB(0) {}
/// runOnFunction - Top level implementation of instruction selection for
/// the entire function.
@ -1116,7 +1113,7 @@ void ISel::LowerUnknownIntrinsicFunctionCalls(Function &F) {
default:
// All other intrinsic calls we must lower.
Instruction *Before = CI->getPrev();
IL.LowerIntrinsicCall(CI);
TM.getIntrinsicLowering().LowerIntrinsicCall(CI);
if (Before) { // Move iterator to instruction after call
I = Before; ++I;
} else {
@ -2196,7 +2193,6 @@ void ISel::visitFreeInst(FreeInst &I) {
/// into a machine code representation is a very simple peep-hole fashion. The
/// generated code sucks but the implementation is nice and simple.
///
FunctionPass *llvm::createX86SimpleInstructionSelector(TargetMachine &TM,
IntrinsicLowering &IL) {
return new ISel(TM, IL);
FunctionPass *llvm::createX86SimpleInstructionSelector(TargetMachine &TM) {
return new ISel(TM);
}

6
lib/Target/X86/X86.h
View File

@ -27,15 +27,13 @@ class IntrinsicLowering;
/// into a machine code representation in a very simple peep-hole fashion. The
/// generated code sucks but the implementation is nice and simple.
///
FunctionPass *createX86SimpleInstructionSelector(TargetMachine &TM,
IntrinsicLowering &IL);
FunctionPass *createX86SimpleInstructionSelector(TargetMachine &TM);
/// createX86PatternInstructionSelector - This pass converts an LLVM function
/// into a machine code representation using pattern matching and a machine
/// description file.
///
FunctionPass *createX86PatternInstructionSelector(TargetMachine &TM,
IntrinsicLowering &IL);
FunctionPass *createX86PatternInstructionSelector(TargetMachine &TM);
/// createX86SSAPeepholeOptimizerPass - Create a pass to perform SSA-based X86
/// specific peephole optimizations.

3
lib/Target/X86/X86ISelPattern.cpp
View File

@ -119,7 +119,6 @@ void ISel::expandCall(SelectionDAG &SD, CallInst &CI) {
/// into a machine code representation using pattern matching and a machine
/// description file.
///
FunctionPass *llvm::createX86PatternInstructionSelector(TargetMachine &TM,
IntrinsicLowering &IL) {
FunctionPass *llvm::createX86PatternInstructionSelector(TargetMachine &TM) {
return new ISel(TM);
}

12
lib/Target/X86/X86ISelSimple.cpp
View File

@ -18,7 +18,6 @@
#include "llvm/DerivedTypes.h"
#include "llvm/Function.h"
#include "llvm/Instructions.h"
#include "llvm/Intrinsics.h"
#include "llvm/IntrinsicLowering.h"
#include "llvm/Pass.h"
#include "llvm/CodeGen/MachineConstantPool.h"
@ -59,7 +58,6 @@ inline static MachineInstrBuilder BMI(MachineBasicBlock *MBB,
namespace {
struct ISel : public FunctionPass, InstVisitor<ISel> {
TargetMachine &TM;
IntrinsicLowering &IL;
MachineFunction *F; // The function we are compiling into
MachineBasicBlock *BB; // The current MBB we are compiling
int VarArgsFrameIndex; // FrameIndex for start of varargs area
@ -69,8 +67,7 @@ namespace {
// MBBMap - Mapping between LLVM BB -> Machine BB
std::map<const BasicBlock*, MachineBasicBlock*> MBBMap;
ISel(TargetMachine &tm, IntrinsicLowering &il)
: TM(tm), IL(il), F(0), BB(0) {}
ISel(TargetMachine &tm) : TM(tm), F(0), BB(0) {}
/// runOnFunction - Top level implementation of instruction selection for
/// the entire function.
@ -1116,7 +1113,7 @@ void ISel::LowerUnknownIntrinsicFunctionCalls(Function &F) {
default:
// All other intrinsic calls we must lower.
Instruction *Before = CI->getPrev();
IL.LowerIntrinsicCall(CI);
TM.getIntrinsicLowering().LowerIntrinsicCall(CI);
if (Before) { // Move iterator to instruction after call
I = Before; ++I;
} else {
@ -2196,7 +2193,6 @@ void ISel::visitFreeInst(FreeInst &I) {
/// into a machine code representation is a very simple peep-hole fashion. The
/// generated code sucks but the implementation is nice and simple.
///
FunctionPass *llvm::createX86SimpleInstructionSelector(TargetMachine &TM,
IntrinsicLowering &IL) {
return new ISel(TM, IL);
FunctionPass *llvm::createX86SimpleInstructionSelector(TargetMachine &TM) {
return new ISel(TM);
}

5
lib/Target/X86/X86JITInfo.h
View File

@ -22,9 +22,8 @@ namespace llvm {
class X86JITInfo : public TargetJITInfo {
TargetMachine &TM;
IntrinsicLowering &IL;
public:
X86JITInfo(TargetMachine &tm, IntrinsicLowering &il) : TM(tm), IL(il) {}
X86JITInfo(TargetMachine &tm) : TM(tm) {}
/// addPassesToJITCompile - Add passes to the specified pass manager to
/// implement a fast dynamic compiler for this target. Return true if this
@ -37,7 +36,7 @@ namespace llvm {
/// overwriting OLD with a branch to NEW. This is used for self-modifying
/// code.
///
virtual void replaceMachineCodeForFunction (void *Old, void *New);
virtual void replaceMachineCodeForFunction(void *Old, void *New);
/// getJITStubForFunction - Create or return a stub for the specified
/// function. This stub acts just like the specified function, except that

19
lib/Target/X86/X86TargetMachine.cpp
View File

@ -45,15 +45,10 @@ TargetMachine *llvm::allocateX86TargetMachine(const Module &M,
/// X86TargetMachine ctor - Create an ILP32 architecture model
///
X86TargetMachine::X86TargetMachine(const Module &M, IntrinsicLowering *il)
: TargetMachine("X86", true, 4, 4, 4, 4, 4),
IL(il ? il : new DefaultIntrinsicLowering()),
X86TargetMachine::X86TargetMachine(const Module &M, IntrinsicLowering *IL)
: TargetMachine("X86", IL, true, 4, 4, 4, 4, 4),
FrameInfo(TargetFrameInfo::StackGrowsDown, 8/*16 for SSE*/, 4),
JITInfo(*this, *IL) {
}
X86TargetMachine::~X86TargetMachine() {
delete IL;
JITInfo(*this) {
}
@ -72,9 +67,9 @@ bool X86TargetMachine::addPassesToEmitAssembly(PassManager &PM,
PM.add(createCFGSimplificationPass());
if (NoPatternISel)
PM.add(createX86SimpleInstructionSelector(*this, *IL));
PM.add(createX86SimpleInstructionSelector(*this));
else
PM.add(createX86PatternInstructionSelector(*this, *IL));
PM.add(createX86PatternInstructionSelector(*this));
// Run optional SSA-based machine code optimizations next...
if (!NoSSAPeephole)
@ -127,9 +122,9 @@ void X86JITInfo::addPassesToJITCompile(FunctionPassManager &PM) {
PM.add(createCFGSimplificationPass());
if (NoPatternISel)
PM.add(createX86SimpleInstructionSelector(TM, IL));
PM.add(createX86SimpleInstructionSelector(TM));
else
PM.add(createX86PatternInstructionSelector(TM, IL));
PM.add(createX86PatternInstructionSelector(TM));
// Run optional SSA-based machine code optimizations next...
if (!NoSSAPeephole)

2
lib/Target/X86/X86TargetMachine.h
View File

@ -24,13 +24,11 @@ namespace llvm {
class IntrinsicLowering;
class X86TargetMachine : public TargetMachine {
IntrinsicLowering *IL;
X86InstrInfo InstrInfo;
TargetFrameInfo FrameInfo;
X86JITInfo JITInfo;
public:
X86TargetMachine(const Module &M, IntrinsicLowering *IL);
~X86TargetMachine();
virtual const X86InstrInfo &getInstrInfo() const { return InstrInfo; }
virtual const TargetFrameInfo &getFrameInfo() const { return FrameInfo; }

1
lib/VMCore/IntrinsicLowering.cpp
View File

@ -13,7 +13,6 @@
#include "llvm/IntrinsicLowering.h"
#include "llvm/Constant.h"
#include "llvm/Intrinsics.h"
#include "llvm/Module.h"
#include "llvm/Type.h"
#include "llvm/iOther.h"