2005-01-07 07:47:53 +00:00
|
|
|
//===-- SelectionDAGISel.cpp - Implement the SelectionDAGISel class -------===//
|
2005-04-21 22:36:52 +00:00
|
|
|
//
|
2005-01-07 07:47:53 +00:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file was developed by the LLVM research group and is distributed under
|
|
|
|
// the University of Illinois Open Source License. See LICENSE.TXT for details.
|
2005-04-21 22:36:52 +00:00
|
|
|
//
|
2005-01-07 07:47:53 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This implements the SelectionDAGISel class.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#define DEBUG_TYPE "isel"
|
|
|
|
#include "llvm/CodeGen/SelectionDAGISel.h"
|
2005-05-13 18:50:42 +00:00
|
|
|
#include "llvm/CallingConv.h"
|
2005-01-07 07:47:53 +00:00
|
|
|
#include "llvm/Constants.h"
|
|
|
|
#include "llvm/DerivedTypes.h"
|
|
|
|
#include "llvm/Function.h"
|
|
|
|
#include "llvm/Instructions.h"
|
|
|
|
#include "llvm/Intrinsics.h"
|
|
|
|
#include "llvm/CodeGen/MachineFunction.h"
|
|
|
|
#include "llvm/CodeGen/MachineFrameInfo.h"
|
|
|
|
#include "llvm/CodeGen/MachineInstrBuilder.h"
|
|
|
|
#include "llvm/CodeGen/SelectionDAG.h"
|
|
|
|
#include "llvm/CodeGen/SSARegMap.h"
|
2005-09-13 19:30:54 +00:00
|
|
|
#include "llvm/Target/MRegisterInfo.h"
|
2005-01-07 07:47:53 +00:00
|
|
|
#include "llvm/Target/TargetData.h"
|
|
|
|
#include "llvm/Target/TargetFrameInfo.h"
|
|
|
|
#include "llvm/Target/TargetInstrInfo.h"
|
|
|
|
#include "llvm/Target/TargetLowering.h"
|
|
|
|
#include "llvm/Target/TargetMachine.h"
|
2005-08-17 06:37:43 +00:00
|
|
|
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
|
2005-01-12 03:41:21 +00:00
|
|
|
#include "llvm/Support/CommandLine.h"
|
2005-11-09 04:45:33 +00:00
|
|
|
#include "llvm/Support/MathExtras.h"
|
2005-01-07 07:47:53 +00:00
|
|
|
#include "llvm/Support/Debug.h"
|
|
|
|
#include <map>
|
|
|
|
#include <iostream>
|
|
|
|
using namespace llvm;
|
|
|
|
|
2005-09-01 18:44:10 +00:00
|
|
|
#ifndef NDEBUG
|
2005-01-12 03:41:21 +00:00
|
|
|
static cl::opt<bool>
|
|
|
|
ViewDAGs("view-isel-dags", cl::Hidden,
|
|
|
|
cl::desc("Pop up a window to show isel dags as they are selected"));
|
|
|
|
#else
|
2005-09-02 07:09:28 +00:00
|
|
|
static const bool ViewDAGs = 0;
|
2005-01-12 03:41:21 +00:00
|
|
|
#endif
|
|
|
|
|
2005-09-07 00:15:36 +00:00
|
|
|
|
2005-01-07 07:47:53 +00:00
|
|
|
namespace llvm {
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
/// FunctionLoweringInfo - This contains information that is global to a
|
|
|
|
/// function that is used when lowering a region of the function.
|
2005-01-08 19:52:31 +00:00
|
|
|
class FunctionLoweringInfo {
|
|
|
|
public:
|
2005-01-07 07:47:53 +00:00
|
|
|
TargetLowering &TLI;
|
|
|
|
Function &Fn;
|
|
|
|
MachineFunction &MF;
|
|
|
|
SSARegMap *RegMap;
|
|
|
|
|
|
|
|
FunctionLoweringInfo(TargetLowering &TLI, Function &Fn,MachineFunction &MF);
|
|
|
|
|
|
|
|
/// MBBMap - A mapping from LLVM basic blocks to their machine code entry.
|
|
|
|
std::map<const BasicBlock*, MachineBasicBlock *> MBBMap;
|
|
|
|
|
|
|
|
/// ValueMap - Since we emit code for the function a basic block at a time,
|
|
|
|
/// we must remember which virtual registers hold the values for
|
|
|
|
/// cross-basic-block values.
|
|
|
|
std::map<const Value*, unsigned> ValueMap;
|
|
|
|
|
|
|
|
/// StaticAllocaMap - Keep track of frame indices for fixed sized allocas in
|
|
|
|
/// the entry block. This allows the allocas to be efficiently referenced
|
|
|
|
/// anywhere in the function.
|
|
|
|
std::map<const AllocaInst*, int> StaticAllocaMap;
|
|
|
|
|
|
|
|
unsigned MakeReg(MVT::ValueType VT) {
|
|
|
|
return RegMap->createVirtualRegister(TLI.getRegClassFor(VT));
|
|
|
|
}
|
2005-04-21 22:36:52 +00:00
|
|
|
|
2005-01-07 07:47:53 +00:00
|
|
|
unsigned CreateRegForValue(const Value *V) {
|
|
|
|
MVT::ValueType VT = TLI.getValueType(V->getType());
|
|
|
|
// The common case is that we will only create one register for this
|
|
|
|
// value. If we have that case, create and return the virtual register.
|
|
|
|
unsigned NV = TLI.getNumElements(VT);
|
2005-01-16 00:37:38 +00:00
|
|
|
if (NV == 1) {
|
|
|
|
// If we are promoting this value, pick the next largest supported type.
|
2005-01-16 01:11:19 +00:00
|
|
|
return MakeReg(TLI.getTypeToTransformTo(VT));
|
2005-01-16 00:37:38 +00:00
|
|
|
}
|
2005-04-21 22:36:52 +00:00
|
|
|
|
2005-01-07 07:47:53 +00:00
|
|
|
// If this value is represented with multiple target registers, make sure
|
|
|
|
// to create enough consequtive registers of the right (smaller) type.
|
|
|
|
unsigned NT = VT-1; // Find the type to use.
|
|
|
|
while (TLI.getNumElements((MVT::ValueType)NT) != 1)
|
|
|
|
--NT;
|
2005-04-21 22:36:52 +00:00
|
|
|
|
2005-01-07 07:47:53 +00:00
|
|
|
unsigned R = MakeReg((MVT::ValueType)NT);
|
|
|
|
for (unsigned i = 1; i != NV; ++i)
|
|
|
|
MakeReg((MVT::ValueType)NT);
|
|
|
|
return R;
|
|
|
|
}
|
2005-04-21 22:36:52 +00:00
|
|
|
|
2005-01-07 07:47:53 +00:00
|
|
|
unsigned InitializeRegForValue(const Value *V) {
|
|
|
|
unsigned &R = ValueMap[V];
|
|
|
|
assert(R == 0 && "Already initialized this value register!");
|
|
|
|
return R = CreateRegForValue(V);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
/// isUsedOutsideOfDefiningBlock - Return true if this instruction is used by
|
|
|
|
/// PHI nodes or outside of the basic block that defines it.
|
|
|
|
static bool isUsedOutsideOfDefiningBlock(Instruction *I) {
|
|
|
|
if (isa<PHINode>(I)) return true;
|
|
|
|
BasicBlock *BB = I->getParent();
|
|
|
|
for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); UI != E; ++UI)
|
|
|
|
if (cast<Instruction>(*UI)->getParent() != BB || isa<PHINode>(*UI))
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
Significantly simplify this code and make it more aggressive. Instead of having
a special case hack for X86, make the hack more general: if an incoming argument
register is not used in any block other than the entry block, don't copy it to
a vreg. This helps us compile code like this:
%struct.foo = type { int, int, [0 x ubyte] }
int %test(%struct.foo* %X) {
%tmp1 = getelementptr %struct.foo* %X, int 0, uint 2, int 100
%tmp = load ubyte* %tmp1 ; <ubyte> [#uses=1]
%tmp2 = cast ubyte %tmp to int ; <int> [#uses=1]
ret int %tmp2
}
to:
_test:
lbz r3, 108(r3)
blr
instead of:
_test:
lbz r2, 108(r3)
or r3, r2, r2
blr
The (dead) copy emitted to copy r3 into a vreg for extra-block uses was
increasing the live range of r3 past the load, preventing the coallescing.
This implements CodeGen/PowerPC/reg-coallesce-simple.ll
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@24115 91177308-0d34-0410-b5e6-96231b3b80d8
2005-10-30 19:42:35 +00:00
|
|
|
/// isOnlyUsedInEntryBlock - If the specified argument is only used in the
|
|
|
|
/// entry block, return true.
|
|
|
|
static bool isOnlyUsedInEntryBlock(Argument *A) {
|
|
|
|
BasicBlock *Entry = A->getParent()->begin();
|
|
|
|
for (Value::use_iterator UI = A->use_begin(), E = A->use_end(); UI != E; ++UI)
|
|
|
|
if (cast<Instruction>(*UI)->getParent() != Entry)
|
|
|
|
return false; // Use not in entry block.
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2005-01-07 07:47:53 +00:00
|
|
|
FunctionLoweringInfo::FunctionLoweringInfo(TargetLowering &tli,
|
2005-04-21 22:36:52 +00:00
|
|
|
Function &fn, MachineFunction &mf)
|
2005-01-07 07:47:53 +00:00
|
|
|
: TLI(tli), Fn(fn), MF(mf), RegMap(MF.getSSARegMap()) {
|
|
|
|
|
Significantly simplify this code and make it more aggressive. Instead of having
a special case hack for X86, make the hack more general: if an incoming argument
register is not used in any block other than the entry block, don't copy it to
a vreg. This helps us compile code like this:
%struct.foo = type { int, int, [0 x ubyte] }
int %test(%struct.foo* %X) {
%tmp1 = getelementptr %struct.foo* %X, int 0, uint 2, int 100
%tmp = load ubyte* %tmp1 ; <ubyte> [#uses=1]
%tmp2 = cast ubyte %tmp to int ; <int> [#uses=1]
ret int %tmp2
}
to:
_test:
lbz r3, 108(r3)
blr
instead of:
_test:
lbz r2, 108(r3)
or r3, r2, r2
blr
The (dead) copy emitted to copy r3 into a vreg for extra-block uses was
increasing the live range of r3 past the load, preventing the coallescing.
This implements CodeGen/PowerPC/reg-coallesce-simple.ll
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@24115 91177308-0d34-0410-b5e6-96231b3b80d8
2005-10-30 19:42:35 +00:00
|
|
|
// Create a vreg for each argument register that is not dead and is used
|
|
|
|
// outside of the entry block for the function.
|
2005-05-11 18:57:06 +00:00
|
|
|
for (Function::arg_iterator AI = Fn.arg_begin(), E = Fn.arg_end();
|
|
|
|
AI != E; ++AI)
|
Significantly simplify this code and make it more aggressive. Instead of having
a special case hack for X86, make the hack more general: if an incoming argument
register is not used in any block other than the entry block, don't copy it to
a vreg. This helps us compile code like this:
%struct.foo = type { int, int, [0 x ubyte] }
int %test(%struct.foo* %X) {
%tmp1 = getelementptr %struct.foo* %X, int 0, uint 2, int 100
%tmp = load ubyte* %tmp1 ; <ubyte> [#uses=1]
%tmp2 = cast ubyte %tmp to int ; <int> [#uses=1]
ret int %tmp2
}
to:
_test:
lbz r3, 108(r3)
blr
instead of:
_test:
lbz r2, 108(r3)
or r3, r2, r2
blr
The (dead) copy emitted to copy r3 into a vreg for extra-block uses was
increasing the live range of r3 past the load, preventing the coallescing.
This implements CodeGen/PowerPC/reg-coallesce-simple.ll
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@24115 91177308-0d34-0410-b5e6-96231b3b80d8
2005-10-30 19:42:35 +00:00
|
|
|
if (!isOnlyUsedInEntryBlock(AI))
|
|
|
|
InitializeRegForValue(AI);
|
2005-01-07 07:47:53 +00:00
|
|
|
|
Significantly simplify this code and make it more aggressive. Instead of having
a special case hack for X86, make the hack more general: if an incoming argument
register is not used in any block other than the entry block, don't copy it to
a vreg. This helps us compile code like this:
%struct.foo = type { int, int, [0 x ubyte] }
int %test(%struct.foo* %X) {
%tmp1 = getelementptr %struct.foo* %X, int 0, uint 2, int 100
%tmp = load ubyte* %tmp1 ; <ubyte> [#uses=1]
%tmp2 = cast ubyte %tmp to int ; <int> [#uses=1]
ret int %tmp2
}
to:
_test:
lbz r3, 108(r3)
blr
instead of:
_test:
lbz r2, 108(r3)
or r3, r2, r2
blr
The (dead) copy emitted to copy r3 into a vreg for extra-block uses was
increasing the live range of r3 past the load, preventing the coallescing.
This implements CodeGen/PowerPC/reg-coallesce-simple.ll
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@24115 91177308-0d34-0410-b5e6-96231b3b80d8
2005-10-30 19:42:35 +00:00
|
|
|
// Initialize the mapping of values to registers. This is only set up for
|
|
|
|
// instruction values that are used outside of the block that defines
|
|
|
|
// them.
|
2005-10-01 03:57:14 +00:00
|
|
|
Function::iterator BB = Fn.begin(), EB = Fn.end();
|
2005-01-07 07:47:53 +00:00
|
|
|
for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I)
|
|
|
|
if (AllocaInst *AI = dyn_cast<AllocaInst>(I))
|
|
|
|
if (ConstantUInt *CUI = dyn_cast<ConstantUInt>(AI->getArraySize())) {
|
|
|
|
const Type *Ty = AI->getAllocatedType();
|
|
|
|
uint64_t TySize = TLI.getTargetData().getTypeSize(Ty);
|
2005-11-06 09:00:38 +00:00
|
|
|
unsigned Align =
|
|
|
|
std::max((unsigned)TLI.getTargetData().getTypeAlignment(Ty),
|
|
|
|
AI->getAlignment());
|
2005-05-13 23:14:17 +00:00
|
|
|
|
|
|
|
// If the alignment of the value is smaller than the size of the value,
|
|
|
|
// and if the size of the value is particularly small (<= 8 bytes),
|
|
|
|
// round up to the size of the value for potentially better performance.
|
|
|
|
//
|
|
|
|
// FIXME: This could be made better with a preferred alignment hook in
|
|
|
|
// TargetData. It serves primarily to 8-byte align doubles for X86.
|
|
|
|
if (Align < TySize && TySize <= 8) Align = TySize;
|
2005-10-18 22:11:42 +00:00
|
|
|
TySize *= CUI->getValue(); // Get total allocated size.
|
2005-10-18 22:14:06 +00:00
|
|
|
if (TySize == 0) TySize = 1; // Don't create zero-sized stack objects.
|
2005-01-07 07:47:53 +00:00
|
|
|
StaticAllocaMap[AI] =
|
2005-01-08 19:52:31 +00:00
|
|
|
MF.getFrameInfo()->CreateStackObject((unsigned)TySize, Align);
|
2005-01-07 07:47:53 +00:00
|
|
|
}
|
|
|
|
|
2005-10-01 03:57:14 +00:00
|
|
|
for (; BB != EB; ++BB)
|
|
|
|
for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I)
|
2005-01-07 07:47:53 +00:00
|
|
|
if (!I->use_empty() && isUsedOutsideOfDefiningBlock(I))
|
|
|
|
if (!isa<AllocaInst>(I) ||
|
|
|
|
!StaticAllocaMap.count(cast<AllocaInst>(I)))
|
|
|
|
InitializeRegForValue(I);
|
|
|
|
|
|
|
|
// Create an initial MachineBasicBlock for each LLVM BasicBlock in F. This
|
|
|
|
// also creates the initial PHI MachineInstrs, though none of the input
|
|
|
|
// operands are populated.
|
2005-10-01 03:57:14 +00:00
|
|
|
for (BB = Fn.begin(), EB = Fn.end(); BB != EB; ++BB) {
|
2005-01-07 07:47:53 +00:00
|
|
|
MachineBasicBlock *MBB = new MachineBasicBlock(BB);
|
|
|
|
MBBMap[BB] = MBB;
|
|
|
|
MF.getBasicBlockList().push_back(MBB);
|
|
|
|
|
|
|
|
// Create Machine PHI nodes for LLVM PHI nodes, lowering them as
|
|
|
|
// appropriate.
|
|
|
|
PHINode *PN;
|
|
|
|
for (BasicBlock::iterator I = BB->begin();
|
2005-01-07 21:34:19 +00:00
|
|
|
(PN = dyn_cast<PHINode>(I)); ++I)
|
|
|
|
if (!PN->use_empty()) {
|
|
|
|
unsigned NumElements =
|
|
|
|
TLI.getNumElements(TLI.getValueType(PN->getType()));
|
|
|
|
unsigned PHIReg = ValueMap[PN];
|
|
|
|
assert(PHIReg &&"PHI node does not have an assigned virtual register!");
|
|
|
|
for (unsigned i = 0; i != NumElements; ++i)
|
|
|
|
BuildMI(MBB, TargetInstrInfo::PHI, PN->getNumOperands(), PHIReg+i);
|
|
|
|
}
|
2005-01-07 07:47:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// SelectionDAGLowering - This is the common target-independent lowering
|
|
|
|
/// implementation that is parameterized by a TargetLowering object.
|
|
|
|
/// Also, targets can overload any lowering method.
|
|
|
|
///
|
|
|
|
namespace llvm {
|
|
|
|
class SelectionDAGLowering {
|
|
|
|
MachineBasicBlock *CurMBB;
|
|
|
|
|
|
|
|
std::map<const Value*, SDOperand> NodeMap;
|
|
|
|
|
2005-01-17 22:19:26 +00:00
|
|
|
/// PendingLoads - Loads are not emitted to the program immediately. We bunch
|
|
|
|
/// them up and then emit token factor nodes when possible. This allows us to
|
|
|
|
/// get simple disambiguation between loads without worrying about alias
|
|
|
|
/// analysis.
|
|
|
|
std::vector<SDOperand> PendingLoads;
|
|
|
|
|
2005-01-07 07:47:53 +00:00
|
|
|
public:
|
|
|
|
// TLI - This is information that describes the available target features we
|
|
|
|
// need for lowering. This indicates when operations are unavailable,
|
|
|
|
// implemented with a libcall, etc.
|
|
|
|
TargetLowering &TLI;
|
|
|
|
SelectionDAG &DAG;
|
|
|
|
const TargetData &TD;
|
|
|
|
|
|
|
|
/// FuncInfo - Information about the function as a whole.
|
|
|
|
///
|
|
|
|
FunctionLoweringInfo &FuncInfo;
|
|
|
|
|
|
|
|
SelectionDAGLowering(SelectionDAG &dag, TargetLowering &tli,
|
2005-04-21 22:36:52 +00:00
|
|
|
FunctionLoweringInfo &funcinfo)
|
2005-01-07 07:47:53 +00:00
|
|
|
: TLI(tli), DAG(dag), TD(DAG.getTarget().getTargetData()),
|
|
|
|
FuncInfo(funcinfo) {
|
|
|
|
}
|
|
|
|
|
2005-01-17 19:43:36 +00:00
|
|
|
/// getRoot - Return the current virtual root of the Selection DAG.
|
|
|
|
///
|
|
|
|
SDOperand getRoot() {
|
2005-01-17 22:19:26 +00:00
|
|
|
if (PendingLoads.empty())
|
|
|
|
return DAG.getRoot();
|
2005-04-21 22:36:52 +00:00
|
|
|
|
2005-01-17 22:19:26 +00:00
|
|
|
if (PendingLoads.size() == 1) {
|
|
|
|
SDOperand Root = PendingLoads[0];
|
|
|
|
DAG.setRoot(Root);
|
|
|
|
PendingLoads.clear();
|
|
|
|
return Root;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise, we have to make a token factor node.
|
|
|
|
SDOperand Root = DAG.getNode(ISD::TokenFactor, MVT::Other, PendingLoads);
|
|
|
|
PendingLoads.clear();
|
|
|
|
DAG.setRoot(Root);
|
|
|
|
return Root;
|
2005-01-17 19:43:36 +00:00
|
|
|
}
|
|
|
|
|
2005-01-07 07:47:53 +00:00
|
|
|
void visit(Instruction &I) { visit(I.getOpcode(), I); }
|
|
|
|
|
|
|
|
void visit(unsigned Opcode, User &I) {
|
|
|
|
switch (Opcode) {
|
|
|
|
default: assert(0 && "Unknown instruction type encountered!");
|
|
|
|
abort();
|
|
|
|
// Build the switch statement using the Instruction.def file.
|
|
|
|
#define HANDLE_INST(NUM, OPCODE, CLASS) \
|
|
|
|
case Instruction::OPCODE:return visit##OPCODE((CLASS&)I);
|
|
|
|
#include "llvm/Instruction.def"
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void setCurrentBasicBlock(MachineBasicBlock *MBB) { CurMBB = MBB; }
|
|
|
|
|
|
|
|
|
|
|
|
SDOperand getIntPtrConstant(uint64_t Val) {
|
|
|
|
return DAG.getConstant(Val, TLI.getPointerTy());
|
|
|
|
}
|
|
|
|
|
|
|
|
SDOperand getValue(const Value *V) {
|
|
|
|
SDOperand &N = NodeMap[V];
|
|
|
|
if (N.Val) return N;
|
|
|
|
|
|
|
|
MVT::ValueType VT = TLI.getValueType(V->getType());
|
|
|
|
if (Constant *C = const_cast<Constant*>(dyn_cast<Constant>(V)))
|
|
|
|
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
|
|
|
|
visit(CE->getOpcode(), *CE);
|
|
|
|
assert(N.Val && "visit didn't populate the ValueMap!");
|
|
|
|
return N;
|
|
|
|
} else if (GlobalValue *GV = dyn_cast<GlobalValue>(C)) {
|
|
|
|
return N = DAG.getGlobalAddress(GV, VT);
|
|
|
|
} else if (isa<ConstantPointerNull>(C)) {
|
|
|
|
return N = DAG.getConstant(0, TLI.getPointerTy());
|
|
|
|
} else if (isa<UndefValue>(C)) {
|
2005-04-12 23:12:17 +00:00
|
|
|
return N = DAG.getNode(ISD::UNDEF, VT);
|
2005-01-07 07:47:53 +00:00
|
|
|
} else if (ConstantFP *CFP = dyn_cast<ConstantFP>(C)) {
|
|
|
|
return N = DAG.getConstantFP(CFP->getValue(), VT);
|
|
|
|
} else {
|
|
|
|
// Canonicalize all constant ints to be unsigned.
|
|
|
|
return N = DAG.getConstant(cast<ConstantIntegral>(C)->getRawValue(),VT);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (const AllocaInst *AI = dyn_cast<AllocaInst>(V)) {
|
|
|
|
std::map<const AllocaInst*, int>::iterator SI =
|
|
|
|
FuncInfo.StaticAllocaMap.find(AI);
|
|
|
|
if (SI != FuncInfo.StaticAllocaMap.end())
|
|
|
|
return DAG.getFrameIndex(SI->second, TLI.getPointerTy());
|
|
|
|
}
|
|
|
|
|
|
|
|
std::map<const Value*, unsigned>::const_iterator VMI =
|
|
|
|
FuncInfo.ValueMap.find(V);
|
|
|
|
assert(VMI != FuncInfo.ValueMap.end() && "Value not in map!");
|
2005-01-16 02:23:07 +00:00
|
|
|
|
2005-08-16 21:55:35 +00:00
|
|
|
unsigned InReg = VMI->second;
|
|
|
|
|
|
|
|
// If this type is not legal, make it so now.
|
|
|
|
MVT::ValueType DestVT = TLI.getTypeToTransformTo(VT);
|
|
|
|
|
|
|
|
N = DAG.getCopyFromReg(DAG.getEntryNode(), InReg, DestVT);
|
|
|
|
if (DestVT < VT) {
|
|
|
|
// Source must be expanded. This input value is actually coming from the
|
|
|
|
// register pair VMI->second and VMI->second+1.
|
|
|
|
N = DAG.getNode(ISD::BUILD_PAIR, VT, N,
|
|
|
|
DAG.getCopyFromReg(DAG.getEntryNode(), InReg+1, DestVT));
|
|
|
|
} else {
|
|
|
|
if (DestVT > VT) { // Promotion case
|
|
|
|
if (MVT::isFloatingPoint(VT))
|
|
|
|
N = DAG.getNode(ISD::FP_ROUND, VT, N);
|
|
|
|
else
|
|
|
|
N = DAG.getNode(ISD::TRUNCATE, VT, N);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return N;
|
2005-01-07 07:47:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
const SDOperand &setValue(const Value *V, SDOperand NewN) {
|
|
|
|
SDOperand &N = NodeMap[V];
|
|
|
|
assert(N.Val == 0 && "Already set a value for this node!");
|
|
|
|
return N = NewN;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Terminator instructions.
|
|
|
|
void visitRet(ReturnInst &I);
|
|
|
|
void visitBr(BranchInst &I);
|
|
|
|
void visitUnreachable(UnreachableInst &I) { /* noop */ }
|
|
|
|
|
|
|
|
// These all get lowered before this pass.
|
|
|
|
void visitSwitch(SwitchInst &I) { assert(0 && "TODO"); }
|
|
|
|
void visitInvoke(InvokeInst &I) { assert(0 && "TODO"); }
|
|
|
|
void visitUnwind(UnwindInst &I) { assert(0 && "TODO"); }
|
|
|
|
|
|
|
|
//
|
2005-08-22 17:28:31 +00:00
|
|
|
void visitBinary(User &I, unsigned Opcode, bool isShift = false);
|
2005-09-28 22:28:18 +00:00
|
|
|
void visitAdd(User &I) {
|
|
|
|
visitBinary(I, I.getType()->isFloatingPoint() ? ISD::FADD : ISD::ADD);
|
|
|
|
}
|
2005-04-02 05:04:50 +00:00
|
|
|
void visitSub(User &I);
|
2005-09-28 22:28:18 +00:00
|
|
|
void visitMul(User &I) {
|
|
|
|
visitBinary(I, I.getType()->isFloatingPoint() ? ISD::FMUL : ISD::MUL);
|
|
|
|
}
|
2005-01-07 07:47:53 +00:00
|
|
|
void visitDiv(User &I) {
|
2005-09-28 22:28:18 +00:00
|
|
|
unsigned Opc;
|
|
|
|
const Type *Ty = I.getType();
|
|
|
|
if (Ty->isFloatingPoint())
|
|
|
|
Opc = ISD::FDIV;
|
|
|
|
else if (Ty->isUnsigned())
|
|
|
|
Opc = ISD::UDIV;
|
|
|
|
else
|
|
|
|
Opc = ISD::SDIV;
|
|
|
|
visitBinary(I, Opc);
|
2005-01-07 07:47:53 +00:00
|
|
|
}
|
|
|
|
void visitRem(User &I) {
|
2005-09-28 22:28:18 +00:00
|
|
|
unsigned Opc;
|
|
|
|
const Type *Ty = I.getType();
|
|
|
|
if (Ty->isFloatingPoint())
|
|
|
|
Opc = ISD::FREM;
|
|
|
|
else if (Ty->isUnsigned())
|
|
|
|
Opc = ISD::UREM;
|
|
|
|
else
|
|
|
|
Opc = ISD::SREM;
|
|
|
|
visitBinary(I, Opc);
|
2005-01-07 07:47:53 +00:00
|
|
|
}
|
|
|
|
void visitAnd(User &I) { visitBinary(I, ISD::AND); }
|
|
|
|
void visitOr (User &I) { visitBinary(I, ISD::OR); }
|
|
|
|
void visitXor(User &I) { visitBinary(I, ISD::XOR); }
|
2005-08-22 17:28:31 +00:00
|
|
|
void visitShl(User &I) { visitBinary(I, ISD::SHL, true); }
|
2005-01-07 07:47:53 +00:00
|
|
|
void visitShr(User &I) {
|
2005-08-22 17:28:31 +00:00
|
|
|
visitBinary(I, I.getType()->isUnsigned() ? ISD::SRL : ISD::SRA, true);
|
2005-01-07 07:47:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void visitSetCC(User &I, ISD::CondCode SignedOpc, ISD::CondCode UnsignedOpc);
|
|
|
|
void visitSetEQ(User &I) { visitSetCC(I, ISD::SETEQ, ISD::SETEQ); }
|
|
|
|
void visitSetNE(User &I) { visitSetCC(I, ISD::SETNE, ISD::SETNE); }
|
|
|
|
void visitSetLE(User &I) { visitSetCC(I, ISD::SETLE, ISD::SETULE); }
|
|
|
|
void visitSetGE(User &I) { visitSetCC(I, ISD::SETGE, ISD::SETUGE); }
|
|
|
|
void visitSetLT(User &I) { visitSetCC(I, ISD::SETLT, ISD::SETULT); }
|
|
|
|
void visitSetGT(User &I) { visitSetCC(I, ISD::SETGT, ISD::SETUGT); }
|
|
|
|
|
|
|
|
void visitGetElementPtr(User &I);
|
|
|
|
void visitCast(User &I);
|
|
|
|
void visitSelect(User &I);
|
|
|
|
//
|
|
|
|
|
|
|
|
void visitMalloc(MallocInst &I);
|
|
|
|
void visitFree(FreeInst &I);
|
|
|
|
void visitAlloca(AllocaInst &I);
|
|
|
|
void visitLoad(LoadInst &I);
|
|
|
|
void visitStore(StoreInst &I);
|
|
|
|
void visitPHI(PHINode &I) { } // PHI nodes are handled specially.
|
|
|
|
void visitCall(CallInst &I);
|
|
|
|
|
|
|
|
void visitVAStart(CallInst &I);
|
|
|
|
void visitVAArg(VAArgInst &I);
|
|
|
|
void visitVAEnd(CallInst &I);
|
|
|
|
void visitVACopy(CallInst &I);
|
2005-01-09 00:00:49 +00:00
|
|
|
void visitFrameReturnAddress(CallInst &I, bool isFrameAddress);
|
2005-01-07 07:47:53 +00:00
|
|
|
|
2005-01-11 05:56:49 +00:00
|
|
|
void visitMemIntrinsic(CallInst &I, unsigned Op);
|
2005-01-07 07:47:53 +00:00
|
|
|
|
|
|
|
void visitUserOp1(Instruction &I) {
|
|
|
|
assert(0 && "UserOp1 should not exist at instruction selection time!");
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
void visitUserOp2(Instruction &I) {
|
|
|
|
assert(0 && "UserOp2 should not exist at instruction selection time!");
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
} // end namespace llvm
|
|
|
|
|
|
|
|
void SelectionDAGLowering::visitRet(ReturnInst &I) {
|
|
|
|
if (I.getNumOperands() == 0) {
|
2005-01-17 19:43:36 +00:00
|
|
|
DAG.setRoot(DAG.getNode(ISD::RET, MVT::Other, getRoot()));
|
2005-01-07 07:47:53 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
SDOperand Op1 = getValue(I.getOperand(0));
|
2005-03-29 19:09:56 +00:00
|
|
|
MVT::ValueType TmpVT;
|
|
|
|
|
2005-01-07 07:47:53 +00:00
|
|
|
switch (Op1.getValueType()) {
|
|
|
|
default: assert(0 && "Unknown value type!");
|
|
|
|
case MVT::i1:
|
|
|
|
case MVT::i8:
|
|
|
|
case MVT::i16:
|
2005-03-29 19:09:56 +00:00
|
|
|
case MVT::i32:
|
|
|
|
// If this is a machine where 32-bits is legal or expanded, promote to
|
|
|
|
// 32-bits, otherwise, promote to 64-bits.
|
|
|
|
if (TLI.getTypeAction(MVT::i32) == TargetLowering::Promote)
|
|
|
|
TmpVT = TLI.getTypeToTransformTo(MVT::i32);
|
|
|
|
else
|
|
|
|
TmpVT = MVT::i32;
|
|
|
|
|
|
|
|
// Extend integer types to result type.
|
2005-01-07 07:47:53 +00:00
|
|
|
if (I.getOperand(0)->getType()->isSigned())
|
2005-03-29 19:09:56 +00:00
|
|
|
Op1 = DAG.getNode(ISD::SIGN_EXTEND, TmpVT, Op1);
|
2005-01-07 07:47:53 +00:00
|
|
|
else
|
2005-03-29 19:09:56 +00:00
|
|
|
Op1 = DAG.getNode(ISD::ZERO_EXTEND, TmpVT, Op1);
|
2005-01-07 07:47:53 +00:00
|
|
|
break;
|
|
|
|
case MVT::f32:
|
|
|
|
case MVT::i64:
|
|
|
|
case MVT::f64:
|
|
|
|
break; // No extension needed!
|
|
|
|
}
|
2005-10-18 23:23:37 +00:00
|
|
|
// Allow targets to lower this further to meet ABI requirements
|
|
|
|
DAG.setRoot(TLI.LowerReturnTo(getRoot(), Op1, DAG));
|
2005-01-07 07:47:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void SelectionDAGLowering::visitBr(BranchInst &I) {
|
|
|
|
// Update machine-CFG edges.
|
|
|
|
MachineBasicBlock *Succ0MBB = FuncInfo.MBBMap[I.getSuccessor(0)];
|
|
|
|
|
|
|
|
// Figure out which block is immediately after the current one.
|
|
|
|
MachineBasicBlock *NextBlock = 0;
|
|
|
|
MachineFunction::iterator BBI = CurMBB;
|
|
|
|
if (++BBI != CurMBB->getParent()->end())
|
|
|
|
NextBlock = BBI;
|
|
|
|
|
|
|
|
if (I.isUnconditional()) {
|
|
|
|
// If this is not a fall-through branch, emit the branch.
|
|
|
|
if (Succ0MBB != NextBlock)
|
2005-01-17 19:43:36 +00:00
|
|
|
DAG.setRoot(DAG.getNode(ISD::BR, MVT::Other, getRoot(),
|
2005-04-22 04:01:18 +00:00
|
|
|
DAG.getBasicBlock(Succ0MBB)));
|
2005-01-07 07:47:53 +00:00
|
|
|
} else {
|
|
|
|
MachineBasicBlock *Succ1MBB = FuncInfo.MBBMap[I.getSuccessor(1)];
|
|
|
|
|
|
|
|
SDOperand Cond = getValue(I.getCondition());
|
|
|
|
if (Succ1MBB == NextBlock) {
|
|
|
|
// If the condition is false, fall through. This means we should branch
|
|
|
|
// if the condition is true to Succ #0.
|
2005-01-17 19:43:36 +00:00
|
|
|
DAG.setRoot(DAG.getNode(ISD::BRCOND, MVT::Other, getRoot(),
|
2005-04-22 04:01:18 +00:00
|
|
|
Cond, DAG.getBasicBlock(Succ0MBB)));
|
2005-01-07 07:47:53 +00:00
|
|
|
} else if (Succ0MBB == NextBlock) {
|
|
|
|
// If the condition is true, fall through. This means we should branch if
|
|
|
|
// the condition is false to Succ #1. Invert the condition first.
|
|
|
|
SDOperand True = DAG.getConstant(1, Cond.getValueType());
|
|
|
|
Cond = DAG.getNode(ISD::XOR, Cond.getValueType(), Cond, True);
|
2005-01-17 19:43:36 +00:00
|
|
|
DAG.setRoot(DAG.getNode(ISD::BRCOND, MVT::Other, getRoot(),
|
2005-04-22 04:01:18 +00:00
|
|
|
Cond, DAG.getBasicBlock(Succ1MBB)));
|
2005-01-07 07:47:53 +00:00
|
|
|
} else {
|
2005-04-09 03:30:29 +00:00
|
|
|
std::vector<SDOperand> Ops;
|
|
|
|
Ops.push_back(getRoot());
|
|
|
|
Ops.push_back(Cond);
|
|
|
|
Ops.push_back(DAG.getBasicBlock(Succ0MBB));
|
|
|
|
Ops.push_back(DAG.getBasicBlock(Succ1MBB));
|
|
|
|
DAG.setRoot(DAG.getNode(ISD::BRCONDTWOWAY, MVT::Other, Ops));
|
2005-01-07 07:47:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-02 05:04:50 +00:00
|
|
|
void SelectionDAGLowering::visitSub(User &I) {
|
|
|
|
// -0.0 - X --> fneg
|
2005-09-28 22:28:18 +00:00
|
|
|
if (I.getType()->isFloatingPoint()) {
|
|
|
|
if (ConstantFP *CFP = dyn_cast<ConstantFP>(I.getOperand(0)))
|
|
|
|
if (CFP->isExactlyValue(-0.0)) {
|
|
|
|
SDOperand Op2 = getValue(I.getOperand(1));
|
|
|
|
setValue(&I, DAG.getNode(ISD::FNEG, Op2.getValueType(), Op2));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
visitBinary(I, ISD::FSUB);
|
|
|
|
} else {
|
|
|
|
visitBinary(I, ISD::SUB);
|
|
|
|
}
|
2005-04-02 05:04:50 +00:00
|
|
|
}
|
|
|
|
|
2005-08-22 17:28:31 +00:00
|
|
|
void SelectionDAGLowering::visitBinary(User &I, unsigned Opcode, bool isShift) {
|
2005-01-07 07:47:53 +00:00
|
|
|
SDOperand Op1 = getValue(I.getOperand(0));
|
|
|
|
SDOperand Op2 = getValue(I.getOperand(1));
|
2005-01-19 22:31:21 +00:00
|
|
|
|
2005-08-22 17:28:31 +00:00
|
|
|
if (isShift)
|
2005-09-02 00:19:37 +00:00
|
|
|
Op2 = DAG.getNode(ISD::ANY_EXTEND, TLI.getShiftAmountTy(), Op2);
|
2005-01-19 22:31:21 +00:00
|
|
|
|
2005-01-07 07:47:53 +00:00
|
|
|
setValue(&I, DAG.getNode(Opcode, Op1.getValueType(), Op1, Op2));
|
|
|
|
}
|
|
|
|
|
|
|
|
void SelectionDAGLowering::visitSetCC(User &I,ISD::CondCode SignedOpcode,
|
|
|
|
ISD::CondCode UnsignedOpcode) {
|
|
|
|
SDOperand Op1 = getValue(I.getOperand(0));
|
|
|
|
SDOperand Op2 = getValue(I.getOperand(1));
|
|
|
|
ISD::CondCode Opcode = SignedOpcode;
|
|
|
|
if (I.getOperand(0)->getType()->isUnsigned())
|
|
|
|
Opcode = UnsignedOpcode;
|
2005-08-09 20:20:18 +00:00
|
|
|
setValue(&I, DAG.getSetCC(MVT::i1, Op1, Op2, Opcode));
|
2005-01-07 07:47:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void SelectionDAGLowering::visitSelect(User &I) {
|
|
|
|
SDOperand Cond = getValue(I.getOperand(0));
|
|
|
|
SDOperand TrueVal = getValue(I.getOperand(1));
|
|
|
|
SDOperand FalseVal = getValue(I.getOperand(2));
|
|
|
|
setValue(&I, DAG.getNode(ISD::SELECT, TrueVal.getValueType(), Cond,
|
|
|
|
TrueVal, FalseVal));
|
|
|
|
}
|
|
|
|
|
|
|
|
void SelectionDAGLowering::visitCast(User &I) {
|
|
|
|
SDOperand N = getValue(I.getOperand(0));
|
|
|
|
MVT::ValueType SrcTy = TLI.getValueType(I.getOperand(0)->getType());
|
|
|
|
MVT::ValueType DestTy = TLI.getValueType(I.getType());
|
|
|
|
|
|
|
|
if (N.getValueType() == DestTy) {
|
|
|
|
setValue(&I, N); // noop cast.
|
2005-05-09 22:17:13 +00:00
|
|
|
} else if (DestTy == MVT::i1) {
|
|
|
|
// Cast to bool is a comparison against zero, not truncation to zero.
|
|
|
|
SDOperand Zero = isInteger(SrcTy) ? DAG.getConstant(0, N.getValueType()) :
|
|
|
|
DAG.getConstantFP(0.0, N.getValueType());
|
2005-08-09 20:20:18 +00:00
|
|
|
setValue(&I, DAG.getSetCC(MVT::i1, N, Zero, ISD::SETNE));
|
2005-01-08 08:08:56 +00:00
|
|
|
} else if (isInteger(SrcTy)) {
|
|
|
|
if (isInteger(DestTy)) { // Int -> Int cast
|
|
|
|
if (DestTy < SrcTy) // Truncating cast?
|
|
|
|
setValue(&I, DAG.getNode(ISD::TRUNCATE, DestTy, N));
|
|
|
|
else if (I.getOperand(0)->getType()->isSigned())
|
|
|
|
setValue(&I, DAG.getNode(ISD::SIGN_EXTEND, DestTy, N));
|
|
|
|
else
|
|
|
|
setValue(&I, DAG.getNode(ISD::ZERO_EXTEND, DestTy, N));
|
|
|
|
} else { // Int -> FP cast
|
|
|
|
if (I.getOperand(0)->getType()->isSigned())
|
|
|
|
setValue(&I, DAG.getNode(ISD::SINT_TO_FP, DestTy, N));
|
|
|
|
else
|
|
|
|
setValue(&I, DAG.getNode(ISD::UINT_TO_FP, DestTy, N));
|
|
|
|
}
|
2005-01-07 07:47:53 +00:00
|
|
|
} else {
|
2005-01-08 08:08:56 +00:00
|
|
|
assert(isFloatingPoint(SrcTy) && "Unknown value type!");
|
|
|
|
if (isFloatingPoint(DestTy)) { // FP -> FP cast
|
|
|
|
if (DestTy < SrcTy) // Rounding cast?
|
|
|
|
setValue(&I, DAG.getNode(ISD::FP_ROUND, DestTy, N));
|
|
|
|
else
|
|
|
|
setValue(&I, DAG.getNode(ISD::FP_EXTEND, DestTy, N));
|
|
|
|
} else { // FP -> Int cast.
|
|
|
|
if (I.getType()->isSigned())
|
|
|
|
setValue(&I, DAG.getNode(ISD::FP_TO_SINT, DestTy, N));
|
|
|
|
else
|
|
|
|
setValue(&I, DAG.getNode(ISD::FP_TO_UINT, DestTy, N));
|
|
|
|
}
|
2005-01-07 07:47:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void SelectionDAGLowering::visitGetElementPtr(User &I) {
|
|
|
|
SDOperand N = getValue(I.getOperand(0));
|
|
|
|
const Type *Ty = I.getOperand(0)->getType();
|
|
|
|
const Type *UIntPtrTy = TD.getIntPtrType();
|
|
|
|
|
|
|
|
for (GetElementPtrInst::op_iterator OI = I.op_begin()+1, E = I.op_end();
|
|
|
|
OI != E; ++OI) {
|
|
|
|
Value *Idx = *OI;
|
|
|
|
if (const StructType *StTy = dyn_cast<StructType> (Ty)) {
|
|
|
|
unsigned Field = cast<ConstantUInt>(Idx)->getValue();
|
|
|
|
if (Field) {
|
|
|
|
// N = N + Offset
|
|
|
|
uint64_t Offset = TD.getStructLayout(StTy)->MemberOffsets[Field];
|
|
|
|
N = DAG.getNode(ISD::ADD, N.getValueType(), N,
|
2005-04-22 04:01:18 +00:00
|
|
|
getIntPtrConstant(Offset));
|
2005-01-07 07:47:53 +00:00
|
|
|
}
|
|
|
|
Ty = StTy->getElementType(Field);
|
|
|
|
} else {
|
|
|
|
Ty = cast<SequentialType>(Ty)->getElementType();
|
2005-11-09 04:45:33 +00:00
|
|
|
|
|
|
|
// If this is a constant subscript, handle it quickly.
|
|
|
|
if (ConstantInt *CI = dyn_cast<ConstantInt>(Idx)) {
|
|
|
|
if (CI->getRawValue() == 0) continue;
|
|
|
|
|
|
|
|
uint64_t Offs;
|
|
|
|
if (ConstantSInt *CSI = dyn_cast<ConstantSInt>(CI))
|
|
|
|
Offs = (int64_t)TD.getTypeSize(Ty)*CSI->getValue();
|
|
|
|
else
|
|
|
|
Offs = TD.getTypeSize(Ty)*cast<ConstantUInt>(CI)->getValue();
|
|
|
|
N = DAG.getNode(ISD::ADD, N.getValueType(), N, getIntPtrConstant(Offs));
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// N = N + Idx * ElementSize;
|
|
|
|
uint64_t ElementSize = TD.getTypeSize(Ty);
|
|
|
|
SDOperand IdxN = getValue(Idx);
|
|
|
|
|
|
|
|
// If the index is smaller or larger than intptr_t, truncate or extend
|
|
|
|
// it.
|
|
|
|
if (IdxN.getValueType() < N.getValueType()) {
|
|
|
|
if (Idx->getType()->isSigned())
|
|
|
|
IdxN = DAG.getNode(ISD::SIGN_EXTEND, N.getValueType(), IdxN);
|
|
|
|
else
|
|
|
|
IdxN = DAG.getNode(ISD::ZERO_EXTEND, N.getValueType(), IdxN);
|
|
|
|
} else if (IdxN.getValueType() > N.getValueType())
|
|
|
|
IdxN = DAG.getNode(ISD::TRUNCATE, N.getValueType(), IdxN);
|
|
|
|
|
|
|
|
// If this is a multiply by a power of two, turn it into a shl
|
|
|
|
// immediately. This is a very common case.
|
|
|
|
if (isPowerOf2_64(ElementSize)) {
|
|
|
|
unsigned Amt = Log2_64(ElementSize);
|
|
|
|
IdxN = DAG.getNode(ISD::SHL, N.getValueType(), IdxN,
|
|
|
|
getIntPtrConstant(Amt));
|
2005-01-07 07:47:53 +00:00
|
|
|
N = DAG.getNode(ISD::ADD, N.getValueType(), N, IdxN);
|
2005-11-09 04:45:33 +00:00
|
|
|
continue;
|
2005-01-07 07:47:53 +00:00
|
|
|
}
|
2005-11-09 04:45:33 +00:00
|
|
|
|
|
|
|
SDOperand Scale = getIntPtrConstant(ElementSize);
|
|
|
|
IdxN = DAG.getNode(ISD::MUL, N.getValueType(), IdxN, Scale);
|
|
|
|
N = DAG.getNode(ISD::ADD, N.getValueType(), N, IdxN);
|
2005-01-07 07:47:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
setValue(&I, N);
|
|
|
|
}
|
|
|
|
|
|
|
|
void SelectionDAGLowering::visitAlloca(AllocaInst &I) {
|
|
|
|
// If this is a fixed sized alloca in the entry block of the function,
|
|
|
|
// allocate it statically on the stack.
|
|
|
|
if (FuncInfo.StaticAllocaMap.count(&I))
|
|
|
|
return; // getValue will auto-populate this.
|
|
|
|
|
|
|
|
const Type *Ty = I.getAllocatedType();
|
|
|
|
uint64_t TySize = TLI.getTargetData().getTypeSize(Ty);
|
2005-11-06 09:00:38 +00:00
|
|
|
unsigned Align = std::max((unsigned)TLI.getTargetData().getTypeAlignment(Ty),
|
|
|
|
I.getAlignment());
|
2005-01-07 07:47:53 +00:00
|
|
|
|
|
|
|
SDOperand AllocSize = getValue(I.getArraySize());
|
2005-01-22 23:04:37 +00:00
|
|
|
MVT::ValueType IntPtr = TLI.getPointerTy();
|
|
|
|
if (IntPtr < AllocSize.getValueType())
|
|
|
|
AllocSize = DAG.getNode(ISD::TRUNCATE, IntPtr, AllocSize);
|
|
|
|
else if (IntPtr > AllocSize.getValueType())
|
|
|
|
AllocSize = DAG.getNode(ISD::ZERO_EXTEND, IntPtr, AllocSize);
|
2005-01-07 07:47:53 +00:00
|
|
|
|
2005-01-22 23:04:37 +00:00
|
|
|
AllocSize = DAG.getNode(ISD::MUL, IntPtr, AllocSize,
|
2005-01-07 07:47:53 +00:00
|
|
|
getIntPtrConstant(TySize));
|
|
|
|
|
|
|
|
// Handle alignment. If the requested alignment is less than or equal to the
|
|
|
|
// stack alignment, ignore it and round the size of the allocation up to the
|
|
|
|
// stack alignment size. If the size is greater than the stack alignment, we
|
|
|
|
// note this in the DYNAMIC_STACKALLOC node.
|
|
|
|
unsigned StackAlign =
|
|
|
|
TLI.getTargetMachine().getFrameInfo()->getStackAlignment();
|
|
|
|
if (Align <= StackAlign) {
|
|
|
|
Align = 0;
|
|
|
|
// Add SA-1 to the size.
|
|
|
|
AllocSize = DAG.getNode(ISD::ADD, AllocSize.getValueType(), AllocSize,
|
|
|
|
getIntPtrConstant(StackAlign-1));
|
|
|
|
// Mask out the low bits for alignment purposes.
|
|
|
|
AllocSize = DAG.getNode(ISD::AND, AllocSize.getValueType(), AllocSize,
|
|
|
|
getIntPtrConstant(~(uint64_t)(StackAlign-1)));
|
|
|
|
}
|
|
|
|
|
2005-05-14 07:29:57 +00:00
|
|
|
std::vector<MVT::ValueType> VTs;
|
|
|
|
VTs.push_back(AllocSize.getValueType());
|
|
|
|
VTs.push_back(MVT::Other);
|
|
|
|
std::vector<SDOperand> Ops;
|
|
|
|
Ops.push_back(getRoot());
|
|
|
|
Ops.push_back(AllocSize);
|
|
|
|
Ops.push_back(getIntPtrConstant(Align));
|
|
|
|
SDOperand DSA = DAG.getNode(ISD::DYNAMIC_STACKALLOC, VTs, Ops);
|
2005-01-07 07:47:53 +00:00
|
|
|
DAG.setRoot(setValue(&I, DSA).getValue(1));
|
|
|
|
|
|
|
|
// Inform the Frame Information that we have just allocated a variable-sized
|
|
|
|
// object.
|
|
|
|
CurMBB->getParent()->getFrameInfo()->CreateVariableSizedObject();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void SelectionDAGLowering::visitLoad(LoadInst &I) {
|
|
|
|
SDOperand Ptr = getValue(I.getOperand(0));
|
2005-04-21 22:36:52 +00:00
|
|
|
|
2005-01-17 22:19:26 +00:00
|
|
|
SDOperand Root;
|
|
|
|
if (I.isVolatile())
|
|
|
|
Root = getRoot();
|
|
|
|
else {
|
|
|
|
// Do not serialize non-volatile loads against each other.
|
|
|
|
Root = DAG.getRoot();
|
|
|
|
}
|
|
|
|
|
2005-05-09 04:08:33 +00:00
|
|
|
SDOperand L = DAG.getLoad(TLI.getValueType(I.getType()), Root, Ptr,
|
2005-06-29 18:54:02 +00:00
|
|
|
DAG.getSrcValue(I.getOperand(0)));
|
2005-01-17 22:19:26 +00:00
|
|
|
setValue(&I, L);
|
|
|
|
|
|
|
|
if (I.isVolatile())
|
|
|
|
DAG.setRoot(L.getValue(1));
|
|
|
|
else
|
|
|
|
PendingLoads.push_back(L.getValue(1));
|
2005-01-07 07:47:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void SelectionDAGLowering::visitStore(StoreInst &I) {
|
|
|
|
Value *SrcV = I.getOperand(0);
|
|
|
|
SDOperand Src = getValue(SrcV);
|
|
|
|
SDOperand Ptr = getValue(I.getOperand(1));
|
2005-05-09 04:08:33 +00:00
|
|
|
DAG.setRoot(DAG.getNode(ISD::STORE, MVT::Other, getRoot(), Src, Ptr,
|
2005-06-29 18:54:02 +00:00
|
|
|
DAG.getSrcValue(I.getOperand(1))));
|
2005-01-07 07:47:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void SelectionDAGLowering::visitCall(CallInst &I) {
|
2005-01-08 22:48:57 +00:00
|
|
|
const char *RenameFn = 0;
|
2005-05-09 20:22:36 +00:00
|
|
|
SDOperand Tmp;
|
2005-01-07 07:47:53 +00:00
|
|
|
if (Function *F = I.getCalledFunction())
|
2005-04-02 05:26:53 +00:00
|
|
|
if (F->isExternal())
|
|
|
|
switch (F->getIntrinsicID()) {
|
|
|
|
case 0: // Not an LLVM intrinsic.
|
|
|
|
if (F->getName() == "fabs" || F->getName() == "fabsf") {
|
|
|
|
if (I.getNumOperands() == 2 && // Basic sanity checks.
|
|
|
|
I.getOperand(1)->getType()->isFloatingPoint() &&
|
|
|
|
I.getType() == I.getOperand(1)->getType()) {
|
2005-05-09 20:22:36 +00:00
|
|
|
Tmp = getValue(I.getOperand(1));
|
2005-04-02 05:26:53 +00:00
|
|
|
setValue(&I, DAG.getNode(ISD::FABS, Tmp.getValueType(), Tmp));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2005-04-30 04:43:14 +00:00
|
|
|
else if (F->getName() == "sin" || F->getName() == "sinf") {
|
|
|
|
if (I.getNumOperands() == 2 && // Basic sanity checks.
|
|
|
|
I.getOperand(1)->getType()->isFloatingPoint() &&
|
|
|
|
I.getType() == I.getOperand(1)->getType()) {
|
2005-05-09 20:22:36 +00:00
|
|
|
Tmp = getValue(I.getOperand(1));
|
2005-04-30 04:43:14 +00:00
|
|
|
setValue(&I, DAG.getNode(ISD::FSIN, Tmp.getValueType(), Tmp));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (F->getName() == "cos" || F->getName() == "cosf") {
|
|
|
|
if (I.getNumOperands() == 2 && // Basic sanity checks.
|
|
|
|
I.getOperand(1)->getType()->isFloatingPoint() &&
|
|
|
|
I.getType() == I.getOperand(1)->getType()) {
|
2005-05-09 20:22:36 +00:00
|
|
|
Tmp = getValue(I.getOperand(1));
|
2005-04-30 04:43:14 +00:00
|
|
|
setValue(&I, DAG.getNode(ISD::FCOS, Tmp.getValueType(), Tmp));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2005-04-02 05:26:53 +00:00
|
|
|
break;
|
|
|
|
case Intrinsic::vastart: visitVAStart(I); return;
|
|
|
|
case Intrinsic::vaend: visitVAEnd(I); return;
|
|
|
|
case Intrinsic::vacopy: visitVACopy(I); return;
|
|
|
|
case Intrinsic::returnaddress: visitFrameReturnAddress(I, false); return;
|
|
|
|
case Intrinsic::frameaddress: visitFrameReturnAddress(I, true); return;
|
2005-05-09 20:22:36 +00:00
|
|
|
|
2005-09-27 22:15:53 +00:00
|
|
|
case Intrinsic::setjmp:
|
|
|
|
RenameFn = "_setjmp"+!TLI.usesUnderscoreSetJmpLongJmp();
|
|
|
|
break;
|
|
|
|
case Intrinsic::longjmp:
|
|
|
|
RenameFn = "_longjmp"+!TLI.usesUnderscoreSetJmpLongJmp();
|
|
|
|
break;
|
2005-04-02 05:26:53 +00:00
|
|
|
case Intrinsic::memcpy: visitMemIntrinsic(I, ISD::MEMCPY); return;
|
|
|
|
case Intrinsic::memset: visitMemIntrinsic(I, ISD::MEMSET); return;
|
|
|
|
case Intrinsic::memmove: visitMemIntrinsic(I, ISD::MEMMOVE); return;
|
2005-04-21 22:36:52 +00:00
|
|
|
|
2005-05-09 20:22:36 +00:00
|
|
|
case Intrinsic::readport:
|
2005-05-14 13:56:55 +00:00
|
|
|
case Intrinsic::readio: {
|
|
|
|
std::vector<MVT::ValueType> VTs;
|
|
|
|
VTs.push_back(TLI.getValueType(I.getType()));
|
|
|
|
VTs.push_back(MVT::Other);
|
|
|
|
std::vector<SDOperand> Ops;
|
|
|
|
Ops.push_back(getRoot());
|
|
|
|
Ops.push_back(getValue(I.getOperand(1)));
|
2005-05-09 20:22:36 +00:00
|
|
|
Tmp = DAG.getNode(F->getIntrinsicID() == Intrinsic::readport ?
|
2005-05-14 13:56:55 +00:00
|
|
|
ISD::READPORT : ISD::READIO, VTs, Ops);
|
2005-07-27 06:12:32 +00:00
|
|
|
|
2005-05-09 20:22:36 +00:00
|
|
|
setValue(&I, Tmp);
|
|
|
|
DAG.setRoot(Tmp.getValue(1));
|
|
|
|
return;
|
2005-05-14 13:56:55 +00:00
|
|
|
}
|
2005-05-09 20:22:36 +00:00
|
|
|
case Intrinsic::writeport:
|
|
|
|
case Intrinsic::writeio:
|
|
|
|
DAG.setRoot(DAG.getNode(F->getIntrinsicID() == Intrinsic::writeport ?
|
|
|
|
ISD::WRITEPORT : ISD::WRITEIO, MVT::Other,
|
|
|
|
getRoot(), getValue(I.getOperand(1)),
|
|
|
|
getValue(I.getOperand(2))));
|
|
|
|
return;
|
2005-05-05 17:55:17 +00:00
|
|
|
case Intrinsic::dbg_stoppoint:
|
|
|
|
case Intrinsic::dbg_region_start:
|
|
|
|
case Intrinsic::dbg_region_end:
|
|
|
|
case Intrinsic::dbg_func_start:
|
|
|
|
case Intrinsic::dbg_declare:
|
|
|
|
if (I.getType() != Type::VoidTy)
|
|
|
|
setValue(&I, DAG.getNode(ISD::UNDEF, TLI.getValueType(I.getType())));
|
|
|
|
return;
|
|
|
|
|
2005-04-02 05:26:53 +00:00
|
|
|
case Intrinsic::isunordered:
|
2005-08-09 20:20:18 +00:00
|
|
|
setValue(&I, DAG.getSetCC(MVT::i1,getValue(I.getOperand(1)),
|
|
|
|
getValue(I.getOperand(2)), ISD::SETUO));
|
2005-04-02 05:26:53 +00:00
|
|
|
return;
|
2005-04-30 04:43:14 +00:00
|
|
|
|
|
|
|
case Intrinsic::sqrt:
|
|
|
|
setValue(&I, DAG.getNode(ISD::FSQRT,
|
|
|
|
getValue(I.getOperand(1)).getValueType(),
|
|
|
|
getValue(I.getOperand(1))));
|
|
|
|
return;
|
|
|
|
|
2005-05-09 20:22:36 +00:00
|
|
|
case Intrinsic::pcmarker:
|
|
|
|
Tmp = getValue(I.getOperand(1));
|
|
|
|
DAG.setRoot(DAG.getNode(ISD::PCMARKER, MVT::Other, getRoot(), Tmp));
|
2005-04-02 05:26:53 +00:00
|
|
|
return;
|
2005-05-03 17:19:30 +00:00
|
|
|
case Intrinsic::cttz:
|
|
|
|
setValue(&I, DAG.getNode(ISD::CTTZ,
|
|
|
|
getValue(I.getOperand(1)).getValueType(),
|
|
|
|
getValue(I.getOperand(1))));
|
|
|
|
return;
|
|
|
|
case Intrinsic::ctlz:
|
|
|
|
setValue(&I, DAG.getNode(ISD::CTLZ,
|
|
|
|
getValue(I.getOperand(1)).getValueType(),
|
|
|
|
getValue(I.getOperand(1))));
|
|
|
|
return;
|
|
|
|
case Intrinsic::ctpop:
|
|
|
|
setValue(&I, DAG.getNode(ISD::CTPOP,
|
|
|
|
getValue(I.getOperand(1)).getValueType(),
|
|
|
|
getValue(I.getOperand(1))));
|
|
|
|
return;
|
2005-05-09 20:22:36 +00:00
|
|
|
default:
|
|
|
|
std::cerr << I;
|
|
|
|
assert(0 && "This intrinsic is not implemented yet!");
|
|
|
|
return;
|
2005-04-02 05:26:53 +00:00
|
|
|
}
|
2005-04-21 22:36:52 +00:00
|
|
|
|
2005-01-08 22:48:57 +00:00
|
|
|
SDOperand Callee;
|
|
|
|
if (!RenameFn)
|
|
|
|
Callee = getValue(I.getOperand(0));
|
|
|
|
else
|
|
|
|
Callee = DAG.getExternalSymbol(RenameFn, TLI.getPointerTy());
|
2005-01-07 07:47:53 +00:00
|
|
|
std::vector<std::pair<SDOperand, const Type*> > Args;
|
2005-04-21 22:36:52 +00:00
|
|
|
|
2005-01-07 07:47:53 +00:00
|
|
|
for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i) {
|
|
|
|
Value *Arg = I.getOperand(i);
|
|
|
|
SDOperand ArgNode = getValue(Arg);
|
|
|
|
Args.push_back(std::make_pair(ArgNode, Arg->getType()));
|
|
|
|
}
|
2005-04-21 22:36:52 +00:00
|
|
|
|
2005-03-26 01:29:23 +00:00
|
|
|
const PointerType *PT = cast<PointerType>(I.getCalledValue()->getType());
|
|
|
|
const FunctionType *FTy = cast<FunctionType>(PT->getElementType());
|
2005-04-21 22:36:52 +00:00
|
|
|
|
2005-01-08 19:26:18 +00:00
|
|
|
std::pair<SDOperand,SDOperand> Result =
|
2005-05-12 19:56:57 +00:00
|
|
|
TLI.LowerCallTo(getRoot(), I.getType(), FTy->isVarArg(), I.getCallingConv(),
|
2005-05-13 18:50:42 +00:00
|
|
|
I.isTailCall(), Callee, Args, DAG);
|
2005-01-07 07:47:53 +00:00
|
|
|
if (I.getType() != Type::VoidTy)
|
2005-01-08 19:26:18 +00:00
|
|
|
setValue(&I, Result.first);
|
|
|
|
DAG.setRoot(Result.second);
|
2005-01-07 07:47:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void SelectionDAGLowering::visitMalloc(MallocInst &I) {
|
|
|
|
SDOperand Src = getValue(I.getOperand(0));
|
|
|
|
|
|
|
|
MVT::ValueType IntPtr = TLI.getPointerTy();
|
2005-01-22 23:04:37 +00:00
|
|
|
|
|
|
|
if (IntPtr < Src.getValueType())
|
|
|
|
Src = DAG.getNode(ISD::TRUNCATE, IntPtr, Src);
|
|
|
|
else if (IntPtr > Src.getValueType())
|
|
|
|
Src = DAG.getNode(ISD::ZERO_EXTEND, IntPtr, Src);
|
2005-01-07 07:47:53 +00:00
|
|
|
|
|
|
|
// Scale the source by the type size.
|
|
|
|
uint64_t ElementSize = TD.getTypeSize(I.getType()->getElementType());
|
|
|
|
Src = DAG.getNode(ISD::MUL, Src.getValueType(),
|
|
|
|
Src, getIntPtrConstant(ElementSize));
|
|
|
|
|
|
|
|
std::vector<std::pair<SDOperand, const Type*> > Args;
|
|
|
|
Args.push_back(std::make_pair(Src, TLI.getTargetData().getIntPtrType()));
|
2005-01-08 19:26:18 +00:00
|
|
|
|
|
|
|
std::pair<SDOperand,SDOperand> Result =
|
2005-05-13 18:50:42 +00:00
|
|
|
TLI.LowerCallTo(getRoot(), I.getType(), false, CallingConv::C, true,
|
2005-01-08 19:26:18 +00:00
|
|
|
DAG.getExternalSymbol("malloc", IntPtr),
|
|
|
|
Args, DAG);
|
|
|
|
setValue(&I, Result.first); // Pointers always fit in registers
|
|
|
|
DAG.setRoot(Result.second);
|
2005-01-07 07:47:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void SelectionDAGLowering::visitFree(FreeInst &I) {
|
|
|
|
std::vector<std::pair<SDOperand, const Type*> > Args;
|
|
|
|
Args.push_back(std::make_pair(getValue(I.getOperand(0)),
|
|
|
|
TLI.getTargetData().getIntPtrType()));
|
|
|
|
MVT::ValueType IntPtr = TLI.getPointerTy();
|
2005-01-08 19:26:18 +00:00
|
|
|
std::pair<SDOperand,SDOperand> Result =
|
2005-05-13 18:50:42 +00:00
|
|
|
TLI.LowerCallTo(getRoot(), Type::VoidTy, false, CallingConv::C, true,
|
2005-01-08 19:26:18 +00:00
|
|
|
DAG.getExternalSymbol("free", IntPtr), Args, DAG);
|
|
|
|
DAG.setRoot(Result.second);
|
2005-01-07 07:47:53 +00:00
|
|
|
}
|
|
|
|
|
2005-08-26 20:54:47 +00:00
|
|
|
// InsertAtEndOfBasicBlock - This method should be implemented by targets that
|
|
|
|
// mark instructions with the 'usesCustomDAGSchedInserter' flag. These
|
|
|
|
// instructions are special in various ways, which require special support to
|
|
|
|
// insert. The specified MachineInstr is created but not inserted into any
|
|
|
|
// basic blocks, and the scheduler passes ownership of it to this method.
|
|
|
|
MachineBasicBlock *TargetLowering::InsertAtEndOfBasicBlock(MachineInstr *MI,
|
|
|
|
MachineBasicBlock *MBB) {
|
|
|
|
std::cerr << "If a target marks an instruction with "
|
|
|
|
"'usesCustomDAGSchedInserter', it must implement "
|
|
|
|
"TargetLowering::InsertAtEndOfBasicBlock!\n";
|
|
|
|
abort();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-10-18 23:23:37 +00:00
|
|
|
SDOperand TargetLowering::LowerReturnTo(SDOperand Chain, SDOperand Op,
|
|
|
|
SelectionDAG &DAG) {
|
|
|
|
return DAG.getNode(ISD::RET, MVT::Other, Chain, Op);
|
|
|
|
}
|
|
|
|
|
2005-07-05 19:57:53 +00:00
|
|
|
SDOperand TargetLowering::LowerVAStart(SDOperand Chain,
|
|
|
|
SDOperand VAListP, Value *VAListV,
|
|
|
|
SelectionDAG &DAG) {
|
2005-01-07 07:47:53 +00:00
|
|
|
// We have no sane default behavior, just emit a useful error message and bail
|
|
|
|
// out.
|
2005-01-09 00:00:49 +00:00
|
|
|
std::cerr << "Variable arguments handling not implemented on this target!\n";
|
2005-01-07 07:47:53 +00:00
|
|
|
abort();
|
2005-07-05 19:57:53 +00:00
|
|
|
return SDOperand();
|
2005-01-07 07:47:53 +00:00
|
|
|
}
|
|
|
|
|
2005-07-05 19:57:53 +00:00
|
|
|
SDOperand TargetLowering::LowerVAEnd(SDOperand Chain, SDOperand LP, Value *LV,
|
2005-01-09 00:00:49 +00:00
|
|
|
SelectionDAG &DAG) {
|
|
|
|
// Default to a noop.
|
|
|
|
return Chain;
|
|
|
|
}
|
|
|
|
|
2005-07-05 19:57:53 +00:00
|
|
|
SDOperand TargetLowering::LowerVACopy(SDOperand Chain,
|
|
|
|
SDOperand SrcP, Value *SrcV,
|
|
|
|
SDOperand DestP, Value *DestV,
|
|
|
|
SelectionDAG &DAG) {
|
|
|
|
// Default to copying the input list.
|
|
|
|
SDOperand Val = DAG.getLoad(getPointerTy(), Chain,
|
|
|
|
SrcP, DAG.getSrcValue(SrcV));
|
2005-06-22 21:04:42 +00:00
|
|
|
SDOperand Result = DAG.getNode(ISD::STORE, MVT::Other, Val.getValue(1),
|
2005-07-05 19:57:53 +00:00
|
|
|
Val, DestP, DAG.getSrcValue(DestV));
|
|
|
|
return Result;
|
2005-01-09 00:00:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
std::pair<SDOperand,SDOperand>
|
2005-07-05 19:57:53 +00:00
|
|
|
TargetLowering::LowerVAArg(SDOperand Chain, SDOperand VAListP, Value *VAListV,
|
|
|
|
const Type *ArgTy, SelectionDAG &DAG) {
|
2005-01-07 07:47:53 +00:00
|
|
|
// We have no sane default behavior, just emit a useful error message and bail
|
|
|
|
// out.
|
2005-01-09 00:00:49 +00:00
|
|
|
std::cerr << "Variable arguments handling not implemented on this target!\n";
|
2005-01-07 07:47:53 +00:00
|
|
|
abort();
|
2005-02-17 21:39:27 +00:00
|
|
|
return std::make_pair(SDOperand(), SDOperand());
|
2005-01-07 07:47:53 +00:00
|
|
|
}
|
2005-01-09 00:00:49 +00:00
|
|
|
|
|
|
|
|
|
|
|
void SelectionDAGLowering::visitVAStart(CallInst &I) {
|
2005-07-05 19:57:53 +00:00
|
|
|
DAG.setRoot(TLI.LowerVAStart(getRoot(), getValue(I.getOperand(1)),
|
|
|
|
I.getOperand(1), DAG));
|
2005-01-09 00:00:49 +00:00
|
|
|
}
|
|
|
|
|
2005-01-07 07:47:53 +00:00
|
|
|
void SelectionDAGLowering::visitVAArg(VAArgInst &I) {
|
2005-01-09 00:00:49 +00:00
|
|
|
std::pair<SDOperand,SDOperand> Result =
|
2005-07-05 19:57:53 +00:00
|
|
|
TLI.LowerVAArg(getRoot(), getValue(I.getOperand(0)), I.getOperand(0),
|
2005-06-18 18:34:52 +00:00
|
|
|
I.getType(), DAG);
|
2005-01-09 00:00:49 +00:00
|
|
|
setValue(&I, Result.first);
|
|
|
|
DAG.setRoot(Result.second);
|
2005-01-07 07:47:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void SelectionDAGLowering::visitVAEnd(CallInst &I) {
|
2005-07-27 06:12:32 +00:00
|
|
|
DAG.setRoot(TLI.LowerVAEnd(getRoot(), getValue(I.getOperand(1)),
|
2005-07-05 19:57:53 +00:00
|
|
|
I.getOperand(1), DAG));
|
2005-01-07 07:47:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void SelectionDAGLowering::visitVACopy(CallInst &I) {
|
2005-07-05 19:57:53 +00:00
|
|
|
SDOperand Result =
|
|
|
|
TLI.LowerVACopy(getRoot(), getValue(I.getOperand(2)), I.getOperand(2),
|
|
|
|
getValue(I.getOperand(1)), I.getOperand(1), DAG);
|
|
|
|
DAG.setRoot(Result);
|
2005-01-07 07:47:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-01-09 00:00:49 +00:00
|
|
|
// It is always conservatively correct for llvm.returnaddress and
|
|
|
|
// llvm.frameaddress to return 0.
|
|
|
|
std::pair<SDOperand, SDOperand>
|
|
|
|
TargetLowering::LowerFrameReturnAddress(bool isFrameAddr, SDOperand Chain,
|
|
|
|
unsigned Depth, SelectionDAG &DAG) {
|
|
|
|
return std::make_pair(DAG.getConstant(0, getPointerTy()), Chain);
|
2005-01-07 07:47:53 +00:00
|
|
|
}
|
|
|
|
|
2005-05-14 05:50:48 +00:00
|
|
|
SDOperand TargetLowering::LowerOperation(SDOperand Op, SelectionDAG &DAG) {
|
2005-01-16 07:28:41 +00:00
|
|
|
assert(0 && "LowerOperation not implemented for this target!");
|
|
|
|
abort();
|
2005-02-17 21:39:27 +00:00
|
|
|
return SDOperand();
|
2005-01-16 07:28:41 +00:00
|
|
|
}
|
|
|
|
|
2005-01-09 00:00:49 +00:00
|
|
|
void SelectionDAGLowering::visitFrameReturnAddress(CallInst &I, bool isFrame) {
|
|
|
|
unsigned Depth = (unsigned)cast<ConstantUInt>(I.getOperand(1))->getValue();
|
|
|
|
std::pair<SDOperand,SDOperand> Result =
|
2005-01-17 19:43:36 +00:00
|
|
|
TLI.LowerFrameReturnAddress(isFrame, getRoot(), Depth, DAG);
|
2005-01-09 00:00:49 +00:00
|
|
|
setValue(&I, Result.first);
|
|
|
|
DAG.setRoot(Result.second);
|
|
|
|
}
|
2005-01-07 07:47:53 +00:00
|
|
|
|
2005-01-11 05:56:49 +00:00
|
|
|
void SelectionDAGLowering::visitMemIntrinsic(CallInst &I, unsigned Op) {
|
|
|
|
std::vector<SDOperand> Ops;
|
2005-01-17 19:43:36 +00:00
|
|
|
Ops.push_back(getRoot());
|
2005-01-11 05:56:49 +00:00
|
|
|
Ops.push_back(getValue(I.getOperand(1)));
|
|
|
|
Ops.push_back(getValue(I.getOperand(2)));
|
|
|
|
Ops.push_back(getValue(I.getOperand(3)));
|
|
|
|
Ops.push_back(getValue(I.getOperand(4)));
|
|
|
|
DAG.setRoot(DAG.getNode(Op, MVT::Other, Ops));
|
2005-01-07 07:47:53 +00:00
|
|
|
}
|
|
|
|
|
2005-01-11 05:56:49 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// SelectionDAGISel code
|
|
|
|
//===----------------------------------------------------------------------===//
|
2005-01-07 07:47:53 +00:00
|
|
|
|
|
|
|
unsigned SelectionDAGISel::MakeReg(MVT::ValueType VT) {
|
|
|
|
return RegMap->createVirtualRegister(TLI.getRegClassFor(VT));
|
|
|
|
}
|
|
|
|
|
2005-08-17 06:37:43 +00:00
|
|
|
void SelectionDAGISel::getAnalysisUsage(AnalysisUsage &AU) const {
|
2005-08-18 17:35:14 +00:00
|
|
|
// FIXME: we only modify the CFG to split critical edges. This
|
|
|
|
// updates dom and loop info.
|
2005-08-17 06:37:43 +00:00
|
|
|
}
|
2005-01-07 07:47:53 +00:00
|
|
|
|
|
|
|
|
|
|
|
bool SelectionDAGISel::runOnFunction(Function &Fn) {
|
|
|
|
MachineFunction &MF = MachineFunction::construct(&Fn, TLI.getTargetMachine());
|
|
|
|
RegMap = MF.getSSARegMap();
|
|
|
|
DEBUG(std::cerr << "\n\n\n=== " << Fn.getName() << "\n");
|
|
|
|
|
2005-08-17 06:37:43 +00:00
|
|
|
// First pass, split all critical edges for PHI nodes with incoming values
|
|
|
|
// that are constants, this way the load of the constant into a vreg will not
|
|
|
|
// be placed into MBBs that are used some other way.
|
2005-08-18 17:35:14 +00:00
|
|
|
for (Function::iterator BB = Fn.begin(), E = Fn.end(); BB != E; ++BB) {
|
|
|
|
PHINode *PN;
|
|
|
|
for (BasicBlock::iterator BBI = BB->begin();
|
|
|
|
(PN = dyn_cast<PHINode>(BBI)); ++BBI)
|
|
|
|
for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i)
|
|
|
|
if (isa<Constant>(PN->getIncomingValue(i)))
|
|
|
|
SplitCriticalEdge(PN->getIncomingBlock(i), BB);
|
|
|
|
}
|
2005-08-17 06:37:43 +00:00
|
|
|
|
2005-01-07 07:47:53 +00:00
|
|
|
FunctionLoweringInfo FuncInfo(TLI, Fn, MF);
|
|
|
|
|
|
|
|
for (Function::iterator I = Fn.begin(), E = Fn.end(); I != E; ++I)
|
|
|
|
SelectBasicBlock(I, MF, FuncInfo);
|
2005-04-21 22:36:52 +00:00
|
|
|
|
2005-01-07 07:47:53 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-01-13 17:59:43 +00:00
|
|
|
SDOperand SelectionDAGISel::
|
|
|
|
CopyValueToVirtualRegister(SelectionDAGLowering &SDL, Value *V, unsigned Reg) {
|
2005-01-11 22:03:46 +00:00
|
|
|
SDOperand Op = SDL.getValue(V);
|
2005-01-13 20:50:02 +00:00
|
|
|
assert((Op.getOpcode() != ISD::CopyFromReg ||
|
2005-08-16 21:55:35 +00:00
|
|
|
cast<RegisterSDNode>(Op.getOperand(1))->getReg() != Reg) &&
|
2005-01-13 20:50:02 +00:00
|
|
|
"Copy from a reg to the same reg!");
|
2005-08-16 21:55:35 +00:00
|
|
|
|
|
|
|
// If this type is not legal, we must make sure to not create an invalid
|
|
|
|
// register use.
|
|
|
|
MVT::ValueType SrcVT = Op.getValueType();
|
|
|
|
MVT::ValueType DestVT = TLI.getTypeToTransformTo(SrcVT);
|
|
|
|
SelectionDAG &DAG = SDL.DAG;
|
|
|
|
if (SrcVT == DestVT) {
|
|
|
|
return DAG.getCopyToReg(SDL.getRoot(), Reg, Op);
|
|
|
|
} else if (SrcVT < DestVT) {
|
|
|
|
// The src value is promoted to the register.
|
2005-08-17 06:06:25 +00:00
|
|
|
if (MVT::isFloatingPoint(SrcVT))
|
|
|
|
Op = DAG.getNode(ISD::FP_EXTEND, DestVT, Op);
|
|
|
|
else
|
2005-09-02 00:19:37 +00:00
|
|
|
Op = DAG.getNode(ISD::ANY_EXTEND, DestVT, Op);
|
2005-08-16 21:55:35 +00:00
|
|
|
return DAG.getCopyToReg(SDL.getRoot(), Reg, Op);
|
|
|
|
} else {
|
|
|
|
// The src value is expanded into multiple registers.
|
|
|
|
SDOperand Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, DestVT,
|
|
|
|
Op, DAG.getConstant(0, MVT::i32));
|
|
|
|
SDOperand Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, DestVT,
|
|
|
|
Op, DAG.getConstant(1, MVT::i32));
|
|
|
|
Op = DAG.getCopyToReg(SDL.getRoot(), Reg, Lo);
|
|
|
|
return DAG.getCopyToReg(Op, Reg+1, Hi);
|
|
|
|
}
|
2005-01-07 07:47:53 +00:00
|
|
|
}
|
|
|
|
|
2005-01-17 17:15:02 +00:00
|
|
|
void SelectionDAGISel::
|
|
|
|
LowerArguments(BasicBlock *BB, SelectionDAGLowering &SDL,
|
|
|
|
std::vector<SDOperand> &UnorderedChains) {
|
2005-01-07 07:47:53 +00:00
|
|
|
// If this is the entry block, emit arguments.
|
2005-01-17 17:15:02 +00:00
|
|
|
Function &F = *BB->getParent();
|
Implement a target independent optimization to codegen arguments only into
the basic block that uses them if possible. This is a big win on X86, as it
lets us fold the argument loads into instructions and reduce register pressure
(by not loading all of the arguments in the entry block).
For this (contrived to show the optimization) testcase:
int %argtest(int %A, int %B) {
%X = sub int 12345, %A
br label %L
L:
%Y = add int %X, %B
ret int %Y
}
we used to produce:
argtest:
mov %ECX, DWORD PTR [%ESP + 4]
mov %EAX, 12345
sub %EAX, %ECX
mov %EDX, DWORD PTR [%ESP + 8]
.LBBargtest_1: # L
add %EAX, %EDX
ret
now we produce:
argtest:
mov %EAX, 12345
sub %EAX, DWORD PTR [%ESP + 4]
.LBBargtest_1: # L
add %EAX, DWORD PTR [%ESP + 8]
ret
This also fixes the FIXME in the code.
BTW, this occurs in real code. 164.gzip shrinks from 8623 to 8608 lines of
.s file. The stack frame in huft_build shrinks from 1644->1628 bytes,
inflate_codes shrinks from 116->108 bytes, and inflate_block from 2620->2612,
due to fewer spills.
Take that alkis. :-)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19639 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-17 17:55:19 +00:00
|
|
|
FunctionLoweringInfo &FuncInfo = SDL.FuncInfo;
|
Significantly simplify this code and make it more aggressive. Instead of having
a special case hack for X86, make the hack more general: if an incoming argument
register is not used in any block other than the entry block, don't copy it to
a vreg. This helps us compile code like this:
%struct.foo = type { int, int, [0 x ubyte] }
int %test(%struct.foo* %X) {
%tmp1 = getelementptr %struct.foo* %X, int 0, uint 2, int 100
%tmp = load ubyte* %tmp1 ; <ubyte> [#uses=1]
%tmp2 = cast ubyte %tmp to int ; <int> [#uses=1]
ret int %tmp2
}
to:
_test:
lbz r3, 108(r3)
blr
instead of:
_test:
lbz r2, 108(r3)
or r3, r2, r2
blr
The (dead) copy emitted to copy r3 into a vreg for extra-block uses was
increasing the live range of r3 past the load, preventing the coallescing.
This implements CodeGen/PowerPC/reg-coallesce-simple.ll
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@24115 91177308-0d34-0410-b5e6-96231b3b80d8
2005-10-30 19:42:35 +00:00
|
|
|
SDOperand OldRoot = SDL.DAG.getRoot();
|
|
|
|
std::vector<SDOperand> Args = TLI.LowerArguments(F, SDL.DAG);
|
|
|
|
|
|
|
|
unsigned a = 0;
|
|
|
|
for (Function::arg_iterator AI = F.arg_begin(), E = F.arg_end();
|
|
|
|
AI != E; ++AI, ++a)
|
|
|
|
if (!AI->use_empty()) {
|
|
|
|
SDL.setValue(AI, Args[a]);
|
2005-09-13 19:30:54 +00:00
|
|
|
|
Significantly simplify this code and make it more aggressive. Instead of having
a special case hack for X86, make the hack more general: if an incoming argument
register is not used in any block other than the entry block, don't copy it to
a vreg. This helps us compile code like this:
%struct.foo = type { int, int, [0 x ubyte] }
int %test(%struct.foo* %X) {
%tmp1 = getelementptr %struct.foo* %X, int 0, uint 2, int 100
%tmp = load ubyte* %tmp1 ; <ubyte> [#uses=1]
%tmp2 = cast ubyte %tmp to int ; <int> [#uses=1]
ret int %tmp2
}
to:
_test:
lbz r3, 108(r3)
blr
instead of:
_test:
lbz r2, 108(r3)
or r3, r2, r2
blr
The (dead) copy emitted to copy r3 into a vreg for extra-block uses was
increasing the live range of r3 past the load, preventing the coallescing.
This implements CodeGen/PowerPC/reg-coallesce-simple.ll
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@24115 91177308-0d34-0410-b5e6-96231b3b80d8
2005-10-30 19:42:35 +00:00
|
|
|
// If this argument is live outside of the entry block, insert a copy from
|
|
|
|
// whereever we got it to the vreg that other BB's will reference it as.
|
|
|
|
if (FuncInfo.ValueMap.count(AI)) {
|
|
|
|
SDOperand Copy =
|
|
|
|
CopyValueToVirtualRegister(SDL, AI, FuncInfo.ValueMap[AI]);
|
|
|
|
UnorderedChains.push_back(Copy);
|
|
|
|
}
|
Implement a target independent optimization to codegen arguments only into
the basic block that uses them if possible. This is a big win on X86, as it
lets us fold the argument loads into instructions and reduce register pressure
(by not loading all of the arguments in the entry block).
For this (contrived to show the optimization) testcase:
int %argtest(int %A, int %B) {
%X = sub int 12345, %A
br label %L
L:
%Y = add int %X, %B
ret int %Y
}
we used to produce:
argtest:
mov %ECX, DWORD PTR [%ESP + 4]
mov %EAX, 12345
sub %EAX, %ECX
mov %EDX, DWORD PTR [%ESP + 8]
.LBBargtest_1: # L
add %EAX, %EDX
ret
now we produce:
argtest:
mov %EAX, 12345
sub %EAX, DWORD PTR [%ESP + 4]
.LBBargtest_1: # L
add %EAX, DWORD PTR [%ESP + 8]
ret
This also fixes the FIXME in the code.
BTW, this occurs in real code. 164.gzip shrinks from 8623 to 8608 lines of
.s file. The stack frame in huft_build shrinks from 1644->1628 bytes,
inflate_codes shrinks from 116->108 bytes, and inflate_block from 2620->2612,
due to fewer spills.
Take that alkis. :-)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19639 91177308-0d34-0410-b5e6-96231b3b80d8
2005-01-17 17:55:19 +00:00
|
|
|
}
|
Significantly simplify this code and make it more aggressive. Instead of having
a special case hack for X86, make the hack more general: if an incoming argument
register is not used in any block other than the entry block, don't copy it to
a vreg. This helps us compile code like this:
%struct.foo = type { int, int, [0 x ubyte] }
int %test(%struct.foo* %X) {
%tmp1 = getelementptr %struct.foo* %X, int 0, uint 2, int 100
%tmp = load ubyte* %tmp1 ; <ubyte> [#uses=1]
%tmp2 = cast ubyte %tmp to int ; <int> [#uses=1]
ret int %tmp2
}
to:
_test:
lbz r3, 108(r3)
blr
instead of:
_test:
lbz r2, 108(r3)
or r3, r2, r2
blr
The (dead) copy emitted to copy r3 into a vreg for extra-block uses was
increasing the live range of r3 past the load, preventing the coallescing.
This implements CodeGen/PowerPC/reg-coallesce-simple.ll
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@24115 91177308-0d34-0410-b5e6-96231b3b80d8
2005-10-30 19:42:35 +00:00
|
|
|
|
|
|
|
// Next, if the function has live ins that need to be copied into vregs,
|
|
|
|
// emit the copies now, into the top of the block.
|
|
|
|
MachineFunction &MF = SDL.DAG.getMachineFunction();
|
|
|
|
if (MF.livein_begin() != MF.livein_end()) {
|
|
|
|
SSARegMap *RegMap = MF.getSSARegMap();
|
|
|
|
const MRegisterInfo &MRI = *MF.getTarget().getRegisterInfo();
|
|
|
|
for (MachineFunction::livein_iterator LI = MF.livein_begin(),
|
|
|
|
E = MF.livein_end(); LI != E; ++LI)
|
|
|
|
if (LI->second)
|
|
|
|
MRI.copyRegToReg(*MF.begin(), MF.begin()->end(), LI->second,
|
|
|
|
LI->first, RegMap->getRegClass(LI->second));
|
2005-01-07 07:47:53 +00:00
|
|
|
}
|
Significantly simplify this code and make it more aggressive. Instead of having
a special case hack for X86, make the hack more general: if an incoming argument
register is not used in any block other than the entry block, don't copy it to
a vreg. This helps us compile code like this:
%struct.foo = type { int, int, [0 x ubyte] }
int %test(%struct.foo* %X) {
%tmp1 = getelementptr %struct.foo* %X, int 0, uint 2, int 100
%tmp = load ubyte* %tmp1 ; <ubyte> [#uses=1]
%tmp2 = cast ubyte %tmp to int ; <int> [#uses=1]
ret int %tmp2
}
to:
_test:
lbz r3, 108(r3)
blr
instead of:
_test:
lbz r2, 108(r3)
or r3, r2, r2
blr
The (dead) copy emitted to copy r3 into a vreg for extra-block uses was
increasing the live range of r3 past the load, preventing the coallescing.
This implements CodeGen/PowerPC/reg-coallesce-simple.ll
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@24115 91177308-0d34-0410-b5e6-96231b3b80d8
2005-10-30 19:42:35 +00:00
|
|
|
|
|
|
|
// Finally, if the target has anything special to do, allow it to do so.
|
|
|
|
EmitFunctionEntryCode(F, SDL.DAG.getMachineFunction());
|
2005-01-17 17:15:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void SelectionDAGISel::BuildSelectionDAG(SelectionDAG &DAG, BasicBlock *LLVMBB,
|
|
|
|
std::vector<std::pair<MachineInstr*, unsigned> > &PHINodesToUpdate,
|
|
|
|
FunctionLoweringInfo &FuncInfo) {
|
|
|
|
SelectionDAGLowering SDL(DAG, TLI, FuncInfo);
|
|
|
|
|
|
|
|
std::vector<SDOperand> UnorderedChains;
|
2005-04-21 22:36:52 +00:00
|
|
|
|
Significantly simplify this code and make it more aggressive. Instead of having
a special case hack for X86, make the hack more general: if an incoming argument
register is not used in any block other than the entry block, don't copy it to
a vreg. This helps us compile code like this:
%struct.foo = type { int, int, [0 x ubyte] }
int %test(%struct.foo* %X) {
%tmp1 = getelementptr %struct.foo* %X, int 0, uint 2, int 100
%tmp = load ubyte* %tmp1 ; <ubyte> [#uses=1]
%tmp2 = cast ubyte %tmp to int ; <int> [#uses=1]
ret int %tmp2
}
to:
_test:
lbz r3, 108(r3)
blr
instead of:
_test:
lbz r2, 108(r3)
or r3, r2, r2
blr
The (dead) copy emitted to copy r3 into a vreg for extra-block uses was
increasing the live range of r3 past the load, preventing the coallescing.
This implements CodeGen/PowerPC/reg-coallesce-simple.ll
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@24115 91177308-0d34-0410-b5e6-96231b3b80d8
2005-10-30 19:42:35 +00:00
|
|
|
// Lower any arguments needed in this block if this is the entry block.
|
|
|
|
if (LLVMBB == &LLVMBB->getParent()->front())
|
|
|
|
LowerArguments(LLVMBB, SDL, UnorderedChains);
|
2005-01-07 07:47:53 +00:00
|
|
|
|
|
|
|
BB = FuncInfo.MBBMap[LLVMBB];
|
|
|
|
SDL.setCurrentBasicBlock(BB);
|
|
|
|
|
|
|
|
// Lower all of the non-terminator instructions.
|
|
|
|
for (BasicBlock::iterator I = LLVMBB->begin(), E = --LLVMBB->end();
|
|
|
|
I != E; ++I)
|
|
|
|
SDL.visit(*I);
|
|
|
|
|
|
|
|
// Ensure that all instructions which are used outside of their defining
|
|
|
|
// blocks are available as virtual registers.
|
|
|
|
for (BasicBlock::iterator I = LLVMBB->begin(), E = LLVMBB->end(); I != E;++I)
|
2005-01-11 22:03:46 +00:00
|
|
|
if (!I->use_empty() && !isa<PHINode>(I)) {
|
2005-01-09 01:16:24 +00:00
|
|
|
std::map<const Value*, unsigned>::iterator VMI =FuncInfo.ValueMap.find(I);
|
2005-01-07 07:47:53 +00:00
|
|
|
if (VMI != FuncInfo.ValueMap.end())
|
2005-01-13 17:59:43 +00:00
|
|
|
UnorderedChains.push_back(
|
|
|
|
CopyValueToVirtualRegister(SDL, I, VMI->second));
|
2005-01-07 07:47:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Handle PHI nodes in successor blocks. Emit code into the SelectionDAG to
|
|
|
|
// ensure constants are generated when needed. Remember the virtual registers
|
|
|
|
// that need to be added to the Machine PHI nodes as input. We cannot just
|
|
|
|
// directly add them, because expansion might result in multiple MBB's for one
|
|
|
|
// BB. As such, the start of the BB might correspond to a different MBB than
|
|
|
|
// the end.
|
2005-04-21 22:36:52 +00:00
|
|
|
//
|
2005-01-07 07:47:53 +00:00
|
|
|
|
|
|
|
// Emit constants only once even if used by multiple PHI nodes.
|
|
|
|
std::map<Constant*, unsigned> ConstantsOut;
|
|
|
|
|
|
|
|
// Check successor nodes PHI nodes that expect a constant to be available from
|
|
|
|
// this block.
|
|
|
|
TerminatorInst *TI = LLVMBB->getTerminator();
|
|
|
|
for (unsigned succ = 0, e = TI->getNumSuccessors(); succ != e; ++succ) {
|
|
|
|
BasicBlock *SuccBB = TI->getSuccessor(succ);
|
|
|
|
MachineBasicBlock::iterator MBBI = FuncInfo.MBBMap[SuccBB]->begin();
|
|
|
|
PHINode *PN;
|
|
|
|
|
|
|
|
// At this point we know that there is a 1-1 correspondence between LLVM PHI
|
|
|
|
// nodes and Machine PHI nodes, but the incoming operands have not been
|
|
|
|
// emitted yet.
|
|
|
|
for (BasicBlock::iterator I = SuccBB->begin();
|
2005-01-07 21:34:19 +00:00
|
|
|
(PN = dyn_cast<PHINode>(I)); ++I)
|
|
|
|
if (!PN->use_empty()) {
|
|
|
|
unsigned Reg;
|
|
|
|
Value *PHIOp = PN->getIncomingValueForBlock(LLVMBB);
|
|
|
|
if (Constant *C = dyn_cast<Constant>(PHIOp)) {
|
|
|
|
unsigned &RegOut = ConstantsOut[C];
|
|
|
|
if (RegOut == 0) {
|
|
|
|
RegOut = FuncInfo.CreateRegForValue(C);
|
2005-01-13 17:59:43 +00:00
|
|
|
UnorderedChains.push_back(
|
|
|
|
CopyValueToVirtualRegister(SDL, C, RegOut));
|
2005-01-07 21:34:19 +00:00
|
|
|
}
|
|
|
|
Reg = RegOut;
|
|
|
|
} else {
|
|
|
|
Reg = FuncInfo.ValueMap[PHIOp];
|
2005-01-09 01:16:24 +00:00
|
|
|
if (Reg == 0) {
|
2005-04-21 22:36:52 +00:00
|
|
|
assert(isa<AllocaInst>(PHIOp) &&
|
2005-01-09 01:16:24 +00:00
|
|
|
FuncInfo.StaticAllocaMap.count(cast<AllocaInst>(PHIOp)) &&
|
|
|
|
"Didn't codegen value into a register!??");
|
|
|
|
Reg = FuncInfo.CreateRegForValue(PHIOp);
|
2005-01-13 17:59:43 +00:00
|
|
|
UnorderedChains.push_back(
|
|
|
|
CopyValueToVirtualRegister(SDL, PHIOp, Reg));
|
2005-01-09 01:16:24 +00:00
|
|
|
}
|
2005-01-07 07:47:53 +00:00
|
|
|
}
|
2005-04-21 22:36:52 +00:00
|
|
|
|
2005-01-07 21:34:19 +00:00
|
|
|
// Remember that this register needs to added to the machine PHI node as
|
|
|
|
// the input for this MBB.
|
|
|
|
unsigned NumElements =
|
|
|
|
TLI.getNumElements(TLI.getValueType(PN->getType()));
|
|
|
|
for (unsigned i = 0, e = NumElements; i != e; ++i)
|
|
|
|
PHINodesToUpdate.push_back(std::make_pair(MBBI++, Reg+i));
|
2005-01-07 07:47:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
ConstantsOut.clear();
|
|
|
|
|
2005-01-13 17:59:43 +00:00
|
|
|
// Turn all of the unordered chains into one factored node.
|
2005-01-13 19:53:14 +00:00
|
|
|
if (!UnorderedChains.empty()) {
|
2005-01-17 22:19:26 +00:00
|
|
|
UnorderedChains.push_back(SDL.getRoot());
|
2005-01-13 17:59:43 +00:00
|
|
|
DAG.setRoot(DAG.getNode(ISD::TokenFactor, MVT::Other, UnorderedChains));
|
|
|
|
}
|
|
|
|
|
2005-01-07 07:47:53 +00:00
|
|
|
// Lower the terminator after the copies are emitted.
|
|
|
|
SDL.visit(*LLVMBB->getTerminator());
|
2005-01-17 19:43:36 +00:00
|
|
|
|
|
|
|
// Make sure the root of the DAG is up-to-date.
|
|
|
|
DAG.setRoot(SDL.getRoot());
|
2005-01-07 07:47:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void SelectionDAGISel::SelectBasicBlock(BasicBlock *LLVMBB, MachineFunction &MF,
|
|
|
|
FunctionLoweringInfo &FuncInfo) {
|
2005-01-23 04:36:26 +00:00
|
|
|
SelectionDAG DAG(TLI, MF);
|
2005-01-07 07:47:53 +00:00
|
|
|
CurDAG = &DAG;
|
|
|
|
std::vector<std::pair<MachineInstr*, unsigned> > PHINodesToUpdate;
|
|
|
|
|
|
|
|
// First step, lower LLVM code to some DAG. This DAG may use operations and
|
|
|
|
// types that are not supported by the target.
|
|
|
|
BuildSelectionDAG(DAG, LLVMBB, PHINodesToUpdate, FuncInfo);
|
|
|
|
|
2005-10-10 16:47:10 +00:00
|
|
|
// Run the DAG combiner in pre-legalize mode.
|
|
|
|
DAG.Combine(false);
|
2005-09-07 00:15:36 +00:00
|
|
|
|
2005-01-07 07:47:53 +00:00
|
|
|
DEBUG(std::cerr << "Lowered selection DAG:\n");
|
|
|
|
DEBUG(DAG.dump());
|
|
|
|
|
|
|
|
// Second step, hack on the DAG until it only uses operations and types that
|
|
|
|
// the target supports.
|
2005-01-23 04:36:26 +00:00
|
|
|
DAG.Legalize();
|
2005-01-07 07:47:53 +00:00
|
|
|
|
|
|
|
DEBUG(std::cerr << "Legalized selection DAG:\n");
|
|
|
|
DEBUG(DAG.dump());
|
|
|
|
|
2005-10-10 16:47:10 +00:00
|
|
|
// Run the DAG combiner in post-legalize mode.
|
|
|
|
DAG.Combine(true);
|
2005-09-07 00:15:36 +00:00
|
|
|
|
2005-10-05 06:09:10 +00:00
|
|
|
if (ViewDAGs) DAG.viewGraph();
|
|
|
|
|
2005-03-30 01:10:47 +00:00
|
|
|
// Third, instruction select all of the operations to machine code, adding the
|
|
|
|
// code to the MachineBasicBlock.
|
2005-01-07 07:47:53 +00:00
|
|
|
InstructionSelectBasicBlock(DAG);
|
|
|
|
|
|
|
|
DEBUG(std::cerr << "Selected machine code:\n");
|
|
|
|
DEBUG(BB->dump());
|
|
|
|
|
2005-03-30 01:10:47 +00:00
|
|
|
// Next, now that we know what the last MBB the LLVM BB expanded is, update
|
2005-01-07 07:47:53 +00:00
|
|
|
// PHI nodes in successors.
|
|
|
|
for (unsigned i = 0, e = PHINodesToUpdate.size(); i != e; ++i) {
|
|
|
|
MachineInstr *PHI = PHINodesToUpdate[i].first;
|
|
|
|
assert(PHI->getOpcode() == TargetInstrInfo::PHI &&
|
|
|
|
"This is not a machine PHI node that we are updating!");
|
|
|
|
PHI->addRegOperand(PHINodesToUpdate[i].second);
|
|
|
|
PHI->addMachineBasicBlockOperand(BB);
|
|
|
|
}
|
2005-03-30 01:10:47 +00:00
|
|
|
|
|
|
|
// Finally, add the CFG edges from the last selected MBB to the successor
|
|
|
|
// MBBs.
|
|
|
|
TerminatorInst *TI = LLVMBB->getTerminator();
|
|
|
|
for (unsigned i = 0, e = TI->getNumSuccessors(); i != e; ++i) {
|
|
|
|
MachineBasicBlock *Succ0MBB = FuncInfo.MBBMap[TI->getSuccessor(i)];
|
|
|
|
BB->addSuccessor(Succ0MBB);
|
|
|
|
}
|
2005-01-07 07:47:53 +00:00
|
|
|
}
|