mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-11-02 07:11:49 +00:00
Define placement new wrappers for BumpPtrAllocator and
RecyclingAllocator to allow client code to be simpler, and simplify several clients. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@98847 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Dan Gohman
parent
5ffc72e7ce
commit
9553188fcc
@ -15,9 +15,12 @@
|
||||
#define LLVM_SUPPORT_ALLOCATOR_H
|
||||
|
||||
#include "llvm/Support/AlignOf.h"
|
||||
#include "llvm/Support/MathExtras.h"
|
||||
#include "llvm/System/DataTypes.h"
|
||||
#include <algorithm>
|
||||
#include <cassert>
|
||||
#include <cstdlib>
|
||||
#include <cstddef>
|
||||
|
||||
namespace llvm {
|
||||
|
||||
@ -175,4 +178,22 @@ public:
|
||||
|
||||
} // end namespace llvm
|
||||
|
||||
inline void *operator new(size_t Size, llvm::BumpPtrAllocator &Allocator) {
|
||||
struct S {
|
||||
char c;
|
||||
#ifdef __GNUC__
|
||||
char x __attribute__((aligned));
|
||||
#else
|
||||
union {
|
||||
double D;
|
||||
long double LD;
|
||||
long long L;
|
||||
void *P;
|
||||
} x;
|
||||
#endif
|
||||
};
|
||||
return Allocator.Allocate(Size, std::min(llvm::NextPowerOf2(Size),
|
||||
offsetof(S, x)));
|
||||
}
|
||||
|
||||
#endif // LLVM_SUPPORT_ALLOCATOR_H
|
||||
|
||||
@ -56,4 +56,11 @@ public:
|
||||
|
||||
}
|
||||
|
||||
template<class AllocatorType, class T, size_t Size, size_t Align>
|
||||
inline void *operator new(size_t,
|
||||
llvm::RecyclingAllocator<AllocatorType,
|
||||
T, Size, Align> &Allocator) {
|
||||
return Allocator.Allocate();
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@ -119,8 +119,7 @@ bool LoopDependenceAnalysis::findOrInsertDependencePair(Value *A,
|
||||
P = Pairs.FindNodeOrInsertPos(id, insertPos);
|
||||
if (P) return true;
|
||||
|
||||
P = PairAllocator.Allocate<DependencePair>();
|
||||
new (P) DependencePair(id, A, B);
|
||||
P = new (PairAllocator) DependencePair(id, A, B);
|
||||
Pairs.InsertNode(P, insertPos);
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -177,8 +177,7 @@ const SCEV *ScalarEvolution::getConstant(ConstantInt *V) {
|
||||
ID.AddPointer(V);
|
||||
void *IP = 0;
|
||||
if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
|
||||
SCEV *S = SCEVAllocator.Allocate<SCEVConstant>();
|
||||
new (S) SCEVConstant(ID.Intern(SCEVAllocator), V);
|
||||
SCEV *S = new (SCEVAllocator) SCEVConstant(ID.Intern(SCEVAllocator), V);
|
||||
UniqueSCEVs.InsertNode(S, IP);
|
||||
return S;
|
||||
}
|
||||
@ -846,8 +845,8 @@ const SCEV *ScalarEvolution::getTruncateExpr(const SCEV *Op,
|
||||
// The cast wasn't folded; create an explicit cast node.
|
||||
// Recompute the insert position, as it may have been invalidated.
|
||||
if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
|
||||
SCEV *S = SCEVAllocator.Allocate<SCEVTruncateExpr>();
|
||||
new (S) SCEVTruncateExpr(ID.Intern(SCEVAllocator), Op, Ty);
|
||||
SCEV *S = new (SCEVAllocator) SCEVTruncateExpr(ID.Intern(SCEVAllocator),
|
||||
Op, Ty);
|
||||
UniqueSCEVs.InsertNode(S, IP);
|
||||
return S;
|
||||
}
|
||||
@ -981,8 +980,8 @@ const SCEV *ScalarEvolution::getZeroExtendExpr(const SCEV *Op,
|
||||
// The cast wasn't folded; create an explicit cast node.
|
||||
// Recompute the insert position, as it may have been invalidated.
|
||||
if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
|
||||
SCEV *S = SCEVAllocator.Allocate<SCEVZeroExtendExpr>();
|
||||
new (S) SCEVZeroExtendExpr(ID.Intern(SCEVAllocator), Op, Ty);
|
||||
SCEV *S = new (SCEVAllocator) SCEVZeroExtendExpr(ID.Intern(SCEVAllocator),
|
||||
Op, Ty);
|
||||
UniqueSCEVs.InsertNode(S, IP);
|
||||
return S;
|
||||
}
|
||||
@ -1116,8 +1115,8 @@ const SCEV *ScalarEvolution::getSignExtendExpr(const SCEV *Op,
|
||||
// The cast wasn't folded; create an explicit cast node.
|
||||
// Recompute the insert position, as it may have been invalidated.
|
||||
if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
|
||||
SCEV *S = SCEVAllocator.Allocate<SCEVSignExtendExpr>();
|
||||
new (S) SCEVSignExtendExpr(ID.Intern(SCEVAllocator), Op, Ty);
|
||||
SCEV *S = new (SCEVAllocator) SCEVSignExtendExpr(ID.Intern(SCEVAllocator),
|
||||
Op, Ty);
|
||||
UniqueSCEVs.InsertNode(S, IP);
|
||||
return S;
|
||||
}
|
||||
@ -1612,10 +1611,10 @@ const SCEV *ScalarEvolution::getAddExpr(SmallVectorImpl<const SCEV *> &Ops,
|
||||
SCEVAddExpr *S =
|
||||
static_cast<SCEVAddExpr *>(UniqueSCEVs.FindNodeOrInsertPos(ID, IP));
|
||||
if (!S) {
|
||||
S = SCEVAllocator.Allocate<SCEVAddExpr>();
|
||||
const SCEV **O = SCEVAllocator.Allocate<const SCEV *>(Ops.size());
|
||||
std::uninitialized_copy(Ops.begin(), Ops.end(), O);
|
||||
new (S) SCEVAddExpr(ID.Intern(SCEVAllocator), O, Ops.size());
|
||||
S = new (SCEVAllocator) SCEVAddExpr(ID.Intern(SCEVAllocator),
|
||||
O, Ops.size());
|
||||
UniqueSCEVs.InsertNode(S, IP);
|
||||
}
|
||||
if (HasNUW) S->setHasNoUnsignedWrap(true);
|
||||
@ -1822,10 +1821,10 @@ const SCEV *ScalarEvolution::getMulExpr(SmallVectorImpl<const SCEV *> &Ops,
|
||||
SCEVMulExpr *S =
|
||||
static_cast<SCEVMulExpr *>(UniqueSCEVs.FindNodeOrInsertPos(ID, IP));
|
||||
if (!S) {
|
||||
S = SCEVAllocator.Allocate<SCEVMulExpr>();
|
||||
const SCEV **O = SCEVAllocator.Allocate<const SCEV *>(Ops.size());
|
||||
std::uninitialized_copy(Ops.begin(), Ops.end(), O);
|
||||
new (S) SCEVMulExpr(ID.Intern(SCEVAllocator), O, Ops.size());
|
||||
S = new (SCEVAllocator) SCEVMulExpr(ID.Intern(SCEVAllocator),
|
||||
O, Ops.size());
|
||||
UniqueSCEVs.InsertNode(S, IP);
|
||||
}
|
||||
if (HasNUW) S->setHasNoUnsignedWrap(true);
|
||||
@ -1924,8 +1923,8 @@ const SCEV *ScalarEvolution::getUDivExpr(const SCEV *LHS,
|
||||
ID.AddPointer(RHS);
|
||||
void *IP = 0;
|
||||
if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
|
||||
SCEV *S = SCEVAllocator.Allocate<SCEVUDivExpr>();
|
||||
new (S) SCEVUDivExpr(ID.Intern(SCEVAllocator), LHS, RHS);
|
||||
SCEV *S = new (SCEVAllocator) SCEVUDivExpr(ID.Intern(SCEVAllocator),
|
||||
LHS, RHS);
|
||||
UniqueSCEVs.InsertNode(S, IP);
|
||||
return S;
|
||||
}
|
||||
@ -2033,10 +2032,10 @@ ScalarEvolution::getAddRecExpr(SmallVectorImpl<const SCEV *> &Operands,
|
||||
SCEVAddRecExpr *S =
|
||||
static_cast<SCEVAddRecExpr *>(UniqueSCEVs.FindNodeOrInsertPos(ID, IP));
|
||||
if (!S) {
|
||||
S = SCEVAllocator.Allocate<SCEVAddRecExpr>();
|
||||
const SCEV **O = SCEVAllocator.Allocate<const SCEV *>(Operands.size());
|
||||
std::uninitialized_copy(Operands.begin(), Operands.end(), O);
|
||||
new (S) SCEVAddRecExpr(ID.Intern(SCEVAllocator), O, Operands.size(), L);
|
||||
S = new (SCEVAllocator) SCEVAddRecExpr(ID.Intern(SCEVAllocator),
|
||||
O, Operands.size(), L);
|
||||
UniqueSCEVs.InsertNode(S, IP);
|
||||
}
|
||||
if (HasNUW) S->setHasNoUnsignedWrap(true);
|
||||
@ -2135,10 +2134,10 @@ ScalarEvolution::getSMaxExpr(SmallVectorImpl<const SCEV *> &Ops) {
|
||||
ID.AddPointer(Ops[i]);
|
||||
void *IP = 0;
|
||||
if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
|
||||
SCEV *S = SCEVAllocator.Allocate<SCEVSMaxExpr>();
|
||||
const SCEV **O = SCEVAllocator.Allocate<const SCEV *>(Ops.size());
|
||||
std::uninitialized_copy(Ops.begin(), Ops.end(), O);
|
||||
new (S) SCEVSMaxExpr(ID.Intern(SCEVAllocator), O, Ops.size());
|
||||
SCEV *S = new (SCEVAllocator) SCEVSMaxExpr(ID.Intern(SCEVAllocator),
|
||||
O, Ops.size());
|
||||
UniqueSCEVs.InsertNode(S, IP);
|
||||
return S;
|
||||
}
|
||||
@ -2234,10 +2233,10 @@ ScalarEvolution::getUMaxExpr(SmallVectorImpl<const SCEV *> &Ops) {
|
||||
ID.AddPointer(Ops[i]);
|
||||
void *IP = 0;
|
||||
if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
|
||||
SCEV *S = SCEVAllocator.Allocate<SCEVUMaxExpr>();
|
||||
const SCEV **O = SCEVAllocator.Allocate<const SCEV *>(Ops.size());
|
||||
std::uninitialized_copy(Ops.begin(), Ops.end(), O);
|
||||
new (S) SCEVUMaxExpr(ID.Intern(SCEVAllocator), O, Ops.size());
|
||||
SCEV *S = new (SCEVAllocator) SCEVUMaxExpr(ID.Intern(SCEVAllocator),
|
||||
O, Ops.size());
|
||||
UniqueSCEVs.InsertNode(S, IP);
|
||||
return S;
|
||||
}
|
||||
@ -2299,8 +2298,7 @@ const SCEV *ScalarEvolution::getUnknown(Value *V) {
|
||||
ID.AddPointer(V);
|
||||
void *IP = 0;
|
||||
if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
|
||||
SCEV *S = SCEVAllocator.Allocate<SCEVUnknown>();
|
||||
new (S) SCEVUnknown(ID.Intern(SCEVAllocator), V);
|
||||
SCEV *S = new (SCEVAllocator) SCEVUnknown(ID.Intern(SCEVAllocator), V);
|
||||
UniqueSCEVs.InsertNode(S, IP);
|
||||
return S;
|
||||
}
|
||||
|
||||
@ -88,18 +88,15 @@ MachineFunction::MachineFunction(Function *F, const TargetMachine &TM,
|
||||
unsigned FunctionNum, MCContext &ctx)
|
||||
: Fn(F), Target(TM), Ctx(ctx) {
|
||||
if (TM.getRegisterInfo())
|
||||
RegInfo = new (Allocator.Allocate<MachineRegisterInfo>())
|
||||
MachineRegisterInfo(*TM.getRegisterInfo());
|
||||
RegInfo = new (Allocator) MachineRegisterInfo(*TM.getRegisterInfo());
|
||||
else
|
||||
RegInfo = 0;
|
||||
MFInfo = 0;
|
||||
FrameInfo = new (Allocator.Allocate<MachineFrameInfo>())
|
||||
MachineFrameInfo(*TM.getFrameInfo());
|
||||
FrameInfo = new (Allocator) MachineFrameInfo(*TM.getFrameInfo());
|
||||
if (Fn->hasFnAttr(Attribute::StackAlignment))
|
||||
FrameInfo->setMaxAlignment(Attribute::getStackAlignmentFromAttrs(
|
||||
Fn->getAttributes().getFnAttributes()));
|
||||
ConstantPool = new (Allocator.Allocate<MachineConstantPool>())
|
||||
MachineConstantPool(TM.getTargetData());
|
||||
ConstantPool = new (Allocator) MachineConstantPool(TM.getTargetData());
|
||||
Alignment = TM.getTargetLowering()->getFunctionAlignment(F);
|
||||
FunctionNumber = FunctionNum;
|
||||
JumpTableInfo = 0;
|
||||
@ -132,7 +129,7 @@ MachineJumpTableInfo *MachineFunction::
|
||||
getOrCreateJumpTableInfo(unsigned EntryKind) {
|
||||
if (JumpTableInfo) return JumpTableInfo;
|
||||
|
||||
JumpTableInfo = new (Allocator.Allocate<MachineJumpTableInfo>())
|
||||
JumpTableInfo = new (Allocator)
|
||||
MachineJumpTableInfo((MachineJumpTableInfo::JTEntryKind)EntryKind);
|
||||
return JumpTableInfo;
|
||||
}
|
||||
@ -229,14 +226,13 @@ MachineMemOperand *
|
||||
MachineFunction::getMachineMemOperand(const Value *v, unsigned f,
|
||||
int64_t o, uint64_t s,
|
||||
unsigned base_alignment) {
|
||||
return new (Allocator.Allocate<MachineMemOperand>())
|
||||
MachineMemOperand(v, f, o, s, base_alignment);
|
||||
return new (Allocator) MachineMemOperand(v, f, o, s, base_alignment);
|
||||
}
|
||||
|
||||
MachineMemOperand *
|
||||
MachineFunction::getMachineMemOperand(const MachineMemOperand *MMO,
|
||||
int64_t Offset, uint64_t Size) {
|
||||
return new (Allocator.Allocate<MachineMemOperand>())
|
||||
return new (Allocator)
|
||||
MachineMemOperand(MMO->getValue(), MMO->getFlags(),
|
||||
int64_t(uint64_t(MMO->getOffset()) +
|
||||
uint64_t(Offset)),
|
||||
|
||||
@ -906,8 +906,7 @@ SDValue SelectionDAG::getConstant(const ConstantInt &Val, EVT VT, bool isT) {
|
||||
return SDValue(N, 0);
|
||||
|
||||
if (!N) {
|
||||
N = NodeAllocator.Allocate<ConstantSDNode>();
|
||||
new (N) ConstantSDNode(isT, &Val, EltVT);
|
||||
N = new (NodeAllocator) ConstantSDNode(isT, &Val, EltVT);
|
||||
CSEMap.InsertNode(N, IP);
|
||||
AllNodes.push_back(N);
|
||||
}
|
||||
@ -950,8 +949,7 @@ SDValue SelectionDAG::getConstantFP(const ConstantFP& V, EVT VT, bool isTarget){
|
||||
return SDValue(N, 0);
|
||||
|
||||
if (!N) {
|
||||
N = NodeAllocator.Allocate<ConstantFPSDNode>();
|
||||
new (N) ConstantFPSDNode(isTarget, &V, EltVT);
|
||||
N = new (NodeAllocator) ConstantFPSDNode(isTarget, &V, EltVT);
|
||||
CSEMap.InsertNode(N, IP);
|
||||
AllNodes.push_back(N);
|
||||
}
|
||||
@ -1010,8 +1008,8 @@ SDValue SelectionDAG::getGlobalAddress(const GlobalValue *GV,
|
||||
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
||||
return SDValue(E, 0);
|
||||
|
||||
SDNode *N = NodeAllocator.Allocate<GlobalAddressSDNode>();
|
||||
new (N) GlobalAddressSDNode(Opc, GV, VT, Offset, TargetFlags);
|
||||
SDNode *N = new (NodeAllocator) GlobalAddressSDNode(Opc, GV, VT,
|
||||
Offset, TargetFlags);
|
||||
CSEMap.InsertNode(N, IP);
|
||||
AllNodes.push_back(N);
|
||||
return SDValue(N, 0);
|
||||
@ -1026,8 +1024,7 @@ SDValue SelectionDAG::getFrameIndex(int FI, EVT VT, bool isTarget) {
|
||||
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
||||
return SDValue(E, 0);
|
||||
|
||||
SDNode *N = NodeAllocator.Allocate<FrameIndexSDNode>();
|
||||
new (N) FrameIndexSDNode(FI, VT, isTarget);
|
||||
SDNode *N = new (NodeAllocator) FrameIndexSDNode(FI, VT, isTarget);
|
||||
CSEMap.InsertNode(N, IP);
|
||||
AllNodes.push_back(N);
|
||||
return SDValue(N, 0);
|
||||
@ -1046,8 +1043,8 @@ SDValue SelectionDAG::getJumpTable(int JTI, EVT VT, bool isTarget,
|
||||
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
||||
return SDValue(E, 0);
|
||||
|
||||
SDNode *N = NodeAllocator.Allocate<JumpTableSDNode>();
|
||||
new (N) JumpTableSDNode(JTI, VT, isTarget, TargetFlags);
|
||||
SDNode *N = new (NodeAllocator) JumpTableSDNode(JTI, VT, isTarget,
|
||||
TargetFlags);
|
||||
CSEMap.InsertNode(N, IP);
|
||||
AllNodes.push_back(N);
|
||||
return SDValue(N, 0);
|
||||
@ -1072,8 +1069,8 @@ SDValue SelectionDAG::getConstantPool(Constant *C, EVT VT,
|
||||
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
||||
return SDValue(E, 0);
|
||||
|
||||
SDNode *N = NodeAllocator.Allocate<ConstantPoolSDNode>();
|
||||
new (N) ConstantPoolSDNode(isTarget, C, VT, Offset, Alignment, TargetFlags);
|
||||
SDNode *N = new (NodeAllocator) ConstantPoolSDNode(isTarget, C, VT, Offset,
|
||||
Alignment, TargetFlags);
|
||||
CSEMap.InsertNode(N, IP);
|
||||
AllNodes.push_back(N);
|
||||
return SDValue(N, 0);
|
||||
@ -1099,8 +1096,8 @@ SDValue SelectionDAG::getConstantPool(MachineConstantPoolValue *C, EVT VT,
|
||||
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
||||
return SDValue(E, 0);
|
||||
|
||||
SDNode *N = NodeAllocator.Allocate<ConstantPoolSDNode>();
|
||||
new (N) ConstantPoolSDNode(isTarget, C, VT, Offset, Alignment, TargetFlags);
|
||||
SDNode *N = new (NodeAllocator) ConstantPoolSDNode(isTarget, C, VT, Offset,
|
||||
Alignment, TargetFlags);
|
||||
CSEMap.InsertNode(N, IP);
|
||||
AllNodes.push_back(N);
|
||||
return SDValue(N, 0);
|
||||
@ -1114,8 +1111,7 @@ SDValue SelectionDAG::getBasicBlock(MachineBasicBlock *MBB) {
|
||||
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
||||
return SDValue(E, 0);
|
||||
|
||||
SDNode *N = NodeAllocator.Allocate<BasicBlockSDNode>();
|
||||
new (N) BasicBlockSDNode(MBB);
|
||||
SDNode *N = new (NodeAllocator) BasicBlockSDNode(MBB);
|
||||
CSEMap.InsertNode(N, IP);
|
||||
AllNodes.push_back(N);
|
||||
return SDValue(N, 0);
|
||||
@ -1130,8 +1126,7 @@ SDValue SelectionDAG::getValueType(EVT VT) {
|
||||
ExtendedValueTypeNodes[VT] : ValueTypeNodes[VT.getSimpleVT().SimpleTy];
|
||||
|
||||
if (N) return SDValue(N, 0);
|
||||
N = NodeAllocator.Allocate<VTSDNode>();
|
||||
new (N) VTSDNode(VT);
|
||||
N = new (NodeAllocator) VTSDNode(VT);
|
||||
AllNodes.push_back(N);
|
||||
return SDValue(N, 0);
|
||||
}
|
||||
@ -1139,8 +1134,7 @@ SDValue SelectionDAG::getValueType(EVT VT) {
|
||||
SDValue SelectionDAG::getExternalSymbol(const char *Sym, EVT VT) {
|
||||
SDNode *&N = ExternalSymbols[Sym];
|
||||
if (N) return SDValue(N, 0);
|
||||
N = NodeAllocator.Allocate<ExternalSymbolSDNode>();
|
||||
new (N) ExternalSymbolSDNode(false, Sym, 0, VT);
|
||||
N = new (NodeAllocator) ExternalSymbolSDNode(false, Sym, 0, VT);
|
||||
AllNodes.push_back(N);
|
||||
return SDValue(N, 0);
|
||||
}
|
||||
@ -1151,8 +1145,7 @@ SDValue SelectionDAG::getTargetExternalSymbol(const char *Sym, EVT VT,
|
||||
TargetExternalSymbols[std::pair<std::string,unsigned char>(Sym,
|
||||
TargetFlags)];
|
||||
if (N) return SDValue(N, 0);
|
||||
N = NodeAllocator.Allocate<ExternalSymbolSDNode>();
|
||||
new (N) ExternalSymbolSDNode(true, Sym, TargetFlags, VT);
|
||||
N = new (NodeAllocator) ExternalSymbolSDNode(true, Sym, TargetFlags, VT);
|
||||
AllNodes.push_back(N);
|
||||
return SDValue(N, 0);
|
||||
}
|
||||
@ -1162,8 +1155,7 @@ SDValue SelectionDAG::getCondCode(ISD::CondCode Cond) {
|
||||
CondCodeNodes.resize(Cond+1);
|
||||
|
||||
if (CondCodeNodes[Cond] == 0) {
|
||||
CondCodeSDNode *N = NodeAllocator.Allocate<CondCodeSDNode>();
|
||||
new (N) CondCodeSDNode(Cond);
|
||||
CondCodeSDNode *N = new (NodeAllocator) CondCodeSDNode(Cond);
|
||||
CondCodeNodes[Cond] = N;
|
||||
AllNodes.push_back(N);
|
||||
}
|
||||
@ -1268,8 +1260,8 @@ SDValue SelectionDAG::getVectorShuffle(EVT VT, DebugLoc dl, SDValue N1,
|
||||
int *MaskAlloc = OperandAllocator.Allocate<int>(NElts);
|
||||
memcpy(MaskAlloc, &MaskVec[0], NElts * sizeof(int));
|
||||
|
||||
ShuffleVectorSDNode *N = NodeAllocator.Allocate<ShuffleVectorSDNode>();
|
||||
new (N) ShuffleVectorSDNode(VT, dl, N1, N2, MaskAlloc);
|
||||
ShuffleVectorSDNode *N =
|
||||
new (NodeAllocator) ShuffleVectorSDNode(VT, dl, N1, N2, MaskAlloc);
|
||||
CSEMap.InsertNode(N, IP);
|
||||
AllNodes.push_back(N);
|
||||
return SDValue(N, 0);
|
||||
@ -1292,8 +1284,8 @@ SDValue SelectionDAG::getConvertRndSat(EVT VT, DebugLoc dl,
|
||||
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
||||
return SDValue(E, 0);
|
||||
|
||||
CvtRndSatSDNode *N = NodeAllocator.Allocate<CvtRndSatSDNode>();
|
||||
new (N) CvtRndSatSDNode(VT, dl, Ops, 5, Code);
|
||||
CvtRndSatSDNode *N = new (NodeAllocator) CvtRndSatSDNode(VT, dl, Ops, 5,
|
||||
Code);
|
||||
CSEMap.InsertNode(N, IP);
|
||||
AllNodes.push_back(N);
|
||||
return SDValue(N, 0);
|
||||
@ -1307,8 +1299,7 @@ SDValue SelectionDAG::getRegister(unsigned RegNo, EVT VT) {
|
||||
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
||||
return SDValue(E, 0);
|
||||
|
||||
SDNode *N = NodeAllocator.Allocate<RegisterSDNode>();
|
||||
new (N) RegisterSDNode(RegNo, VT);
|
||||
SDNode *N = new (NodeAllocator) RegisterSDNode(RegNo, VT);
|
||||
CSEMap.InsertNode(N, IP);
|
||||
AllNodes.push_back(N);
|
||||
return SDValue(N, 0);
|
||||
@ -1323,8 +1314,7 @@ SDValue SelectionDAG::getEHLabel(DebugLoc dl, SDValue Root, MCSymbol *Label) {
|
||||
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
||||
return SDValue(E, 0);
|
||||
|
||||
SDNode *N = NodeAllocator.Allocate<EHLabelSDNode>();
|
||||
new (N) EHLabelSDNode(dl, Root, Label);
|
||||
SDNode *N = new (NodeAllocator) EHLabelSDNode(dl, Root, Label);
|
||||
CSEMap.InsertNode(N, IP);
|
||||
AllNodes.push_back(N);
|
||||
return SDValue(N, 0);
|
||||
@ -1344,8 +1334,7 @@ SDValue SelectionDAG::getBlockAddress(BlockAddress *BA, EVT VT,
|
||||
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
||||
return SDValue(E, 0);
|
||||
|
||||
SDNode *N = NodeAllocator.Allocate<BlockAddressSDNode>();
|
||||
new (N) BlockAddressSDNode(Opc, VT, BA, TargetFlags);
|
||||
SDNode *N = new (NodeAllocator) BlockAddressSDNode(Opc, VT, BA, TargetFlags);
|
||||
CSEMap.InsertNode(N, IP);
|
||||
AllNodes.push_back(N);
|
||||
return SDValue(N, 0);
|
||||
@ -1363,8 +1352,7 @@ SDValue SelectionDAG::getSrcValue(const Value *V) {
|
||||
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
||||
return SDValue(E, 0);
|
||||
|
||||
SDNode *N = NodeAllocator.Allocate<SrcValueSDNode>();
|
||||
new (N) SrcValueSDNode(V);
|
||||
SDNode *N = new (NodeAllocator) SrcValueSDNode(V);
|
||||
CSEMap.InsertNode(N, IP);
|
||||
AllNodes.push_back(N);
|
||||
return SDValue(N, 0);
|
||||
@ -2313,8 +2301,7 @@ SDValue SelectionDAG::getNode(unsigned Opcode, DebugLoc DL, EVT VT) {
|
||||
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
||||
return SDValue(E, 0);
|
||||
|
||||
SDNode *N = NodeAllocator.Allocate<SDNode>();
|
||||
new (N) SDNode(Opcode, DL, getVTList(VT));
|
||||
SDNode *N = new (NodeAllocator) SDNode(Opcode, DL, getVTList(VT));
|
||||
CSEMap.InsertNode(N, IP);
|
||||
|
||||
AllNodes.push_back(N);
|
||||
@ -2542,12 +2529,10 @@ SDValue SelectionDAG::getNode(unsigned Opcode, DebugLoc DL,
|
||||
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
||||
return SDValue(E, 0);
|
||||
|
||||
N = NodeAllocator.Allocate<UnarySDNode>();
|
||||
new (N) UnarySDNode(Opcode, DL, VTs, Operand);
|
||||
N = new (NodeAllocator) UnarySDNode(Opcode, DL, VTs, Operand);
|
||||
CSEMap.InsertNode(N, IP);
|
||||
} else {
|
||||
N = NodeAllocator.Allocate<UnarySDNode>();
|
||||
new (N) UnarySDNode(Opcode, DL, VTs, Operand);
|
||||
N = new (NodeAllocator) UnarySDNode(Opcode, DL, VTs, Operand);
|
||||
}
|
||||
|
||||
AllNodes.push_back(N);
|
||||
@ -2975,12 +2960,10 @@ SDValue SelectionDAG::getNode(unsigned Opcode, DebugLoc DL, EVT VT,
|
||||
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
||||
return SDValue(E, 0);
|
||||
|
||||
N = NodeAllocator.Allocate<BinarySDNode>();
|
||||
new (N) BinarySDNode(Opcode, DL, VTs, N1, N2);
|
||||
N = new (NodeAllocator) BinarySDNode(Opcode, DL, VTs, N1, N2);
|
||||
CSEMap.InsertNode(N, IP);
|
||||
} else {
|
||||
N = NodeAllocator.Allocate<BinarySDNode>();
|
||||
new (N) BinarySDNode(Opcode, DL, VTs, N1, N2);
|
||||
N = new (NodeAllocator) BinarySDNode(Opcode, DL, VTs, N1, N2);
|
||||
}
|
||||
|
||||
AllNodes.push_back(N);
|
||||
@ -3053,12 +3036,10 @@ SDValue SelectionDAG::getNode(unsigned Opcode, DebugLoc DL, EVT VT,
|
||||
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
||||
return SDValue(E, 0);
|
||||
|
||||
N = NodeAllocator.Allocate<TernarySDNode>();
|
||||
new (N) TernarySDNode(Opcode, DL, VTs, N1, N2, N3);
|
||||
N = new (NodeAllocator) TernarySDNode(Opcode, DL, VTs, N1, N2, N3);
|
||||
CSEMap.InsertNode(N, IP);
|
||||
} else {
|
||||
N = NodeAllocator.Allocate<TernarySDNode>();
|
||||
new (N) TernarySDNode(Opcode, DL, VTs, N1, N2, N3);
|
||||
N = new (NodeAllocator) TernarySDNode(Opcode, DL, VTs, N1, N2, N3);
|
||||
}
|
||||
|
||||
AllNodes.push_back(N);
|
||||
@ -3659,8 +3640,8 @@ SDValue SelectionDAG::getAtomic(unsigned Opcode, DebugLoc dl, EVT MemVT,
|
||||
cast<AtomicSDNode>(E)->refineAlignment(MMO);
|
||||
return SDValue(E, 0);
|
||||
}
|
||||
SDNode* N = NodeAllocator.Allocate<AtomicSDNode>();
|
||||
new (N) AtomicSDNode(Opcode, dl, VTs, MemVT, Chain, Ptr, Cmp, Swp, MMO);
|
||||
SDNode *N = new (NodeAllocator) AtomicSDNode(Opcode, dl, VTs, MemVT, Chain,
|
||||
Ptr, Cmp, Swp, MMO);
|
||||
CSEMap.InsertNode(N, IP);
|
||||
AllNodes.push_back(N);
|
||||
return SDValue(N, 0);
|
||||
@ -3722,8 +3703,8 @@ SDValue SelectionDAG::getAtomic(unsigned Opcode, DebugLoc dl, EVT MemVT,
|
||||
cast<AtomicSDNode>(E)->refineAlignment(MMO);
|
||||
return SDValue(E, 0);
|
||||
}
|
||||
SDNode* N = NodeAllocator.Allocate<AtomicSDNode>();
|
||||
new (N) AtomicSDNode(Opcode, dl, VTs, MemVT, Chain, Ptr, Val, MMO);
|
||||
SDNode *N = new (NodeAllocator) AtomicSDNode(Opcode, dl, VTs, MemVT, Chain,
|
||||
Ptr, Val, MMO);
|
||||
CSEMap.InsertNode(N, IP);
|
||||
AllNodes.push_back(N);
|
||||
return SDValue(N, 0);
|
||||
@ -3801,12 +3782,12 @@ SelectionDAG::getMemIntrinsicNode(unsigned Opcode, DebugLoc dl, SDVTList VTList,
|
||||
return SDValue(E, 0);
|
||||
}
|
||||
|
||||
N = NodeAllocator.Allocate<MemIntrinsicSDNode>();
|
||||
new (N) MemIntrinsicSDNode(Opcode, dl, VTList, Ops, NumOps, MemVT, MMO);
|
||||
N = new (NodeAllocator) MemIntrinsicSDNode(Opcode, dl, VTList, Ops, NumOps,
|
||||
MemVT, MMO);
|
||||
CSEMap.InsertNode(N, IP);
|
||||
} else {
|
||||
N = NodeAllocator.Allocate<MemIntrinsicSDNode>();
|
||||
new (N) MemIntrinsicSDNode(Opcode, dl, VTList, Ops, NumOps, MemVT, MMO);
|
||||
N = new (NodeAllocator) MemIntrinsicSDNode(Opcode, dl, VTList, Ops, NumOps,
|
||||
MemVT, MMO);
|
||||
}
|
||||
AllNodes.push_back(N);
|
||||
return SDValue(N, 0);
|
||||
@ -3879,8 +3860,8 @@ SelectionDAG::getLoad(ISD::MemIndexedMode AM, DebugLoc dl,
|
||||
cast<LoadSDNode>(E)->refineAlignment(MMO);
|
||||
return SDValue(E, 0);
|
||||
}
|
||||
SDNode *N = NodeAllocator.Allocate<LoadSDNode>();
|
||||
new (N) LoadSDNode(Ops, dl, VTs, AM, ExtType, MemVT, MMO);
|
||||
SDNode *N = new (NodeAllocator) LoadSDNode(Ops, dl, VTs, AM, ExtType,
|
||||
MemVT, MMO);
|
||||
CSEMap.InsertNode(N, IP);
|
||||
AllNodes.push_back(N);
|
||||
return SDValue(N, 0);
|
||||
@ -3961,8 +3942,8 @@ SDValue SelectionDAG::getStore(SDValue Chain, DebugLoc dl, SDValue Val,
|
||||
cast<StoreSDNode>(E)->refineAlignment(MMO);
|
||||
return SDValue(E, 0);
|
||||
}
|
||||
SDNode *N = NodeAllocator.Allocate<StoreSDNode>();
|
||||
new (N) StoreSDNode(Ops, dl, VTs, ISD::UNINDEXED, false, VT, MMO);
|
||||
SDNode *N = new (NodeAllocator) StoreSDNode(Ops, dl, VTs, ISD::UNINDEXED,
|
||||
false, VT, MMO);
|
||||
CSEMap.InsertNode(N, IP);
|
||||
AllNodes.push_back(N);
|
||||
return SDValue(N, 0);
|
||||
@ -4025,8 +4006,8 @@ SDValue SelectionDAG::getTruncStore(SDValue Chain, DebugLoc dl, SDValue Val,
|
||||
cast<StoreSDNode>(E)->refineAlignment(MMO);
|
||||
return SDValue(E, 0);
|
||||
}
|
||||
SDNode *N = NodeAllocator.Allocate<StoreSDNode>();
|
||||
new (N) StoreSDNode(Ops, dl, VTs, ISD::UNINDEXED, true, SVT, MMO);
|
||||
SDNode *N = new (NodeAllocator) StoreSDNode(Ops, dl, VTs, ISD::UNINDEXED,
|
||||
true, SVT, MMO);
|
||||
CSEMap.InsertNode(N, IP);
|
||||
AllNodes.push_back(N);
|
||||
return SDValue(N, 0);
|
||||
@ -4048,10 +4029,10 @@ SelectionDAG::getIndexedStore(SDValue OrigStore, DebugLoc dl, SDValue Base,
|
||||
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
||||
return SDValue(E, 0);
|
||||
|
||||
SDNode *N = NodeAllocator.Allocate<StoreSDNode>();
|
||||
new (N) StoreSDNode(Ops, dl, VTs, AM,
|
||||
ST->isTruncatingStore(), ST->getMemoryVT(),
|
||||
ST->getMemOperand());
|
||||
SDNode *N = new (NodeAllocator) StoreSDNode(Ops, dl, VTs, AM,
|
||||
ST->isTruncatingStore(),
|
||||
ST->getMemoryVT(),
|
||||
ST->getMemOperand());
|
||||
CSEMap.InsertNode(N, IP);
|
||||
AllNodes.push_back(N);
|
||||
return SDValue(N, 0);
|
||||
@ -4122,12 +4103,10 @@ SDValue SelectionDAG::getNode(unsigned Opcode, DebugLoc DL, EVT VT,
|
||||
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
|
||||
return SDValue(E, 0);
|
||||
|
||||
N = NodeAllocator.Allocate<SDNode>();
|
||||
new (N) SDNode(Opcode, DL, VTs, Ops, NumOps);
|
||||
N = new (NodeAllocator) SDNode(Opcode, DL, VTs, Ops, NumOps);
|
||||
CSEMap.InsertNode(N, IP);
|
||||
} else {
|
||||
N = NodeAllocator.Allocate<SDNode>();
|
||||
new (N) SDNode(Opcode, DL, VTs, Ops, NumOps);
|
||||
N = new (NodeAllocator) SDNode(Opcode, DL, VTs, Ops, NumOps);
|
||||
}
|
||||
|
||||
AllNodes.push_back(N);
|
||||
@ -4190,32 +4169,26 @@ SDValue SelectionDAG::getNode(unsigned Opcode, DebugLoc DL, SDVTList VTList,
|
||||
return SDValue(E, 0);
|
||||
|
||||
if (NumOps == 1) {
|
||||
N = NodeAllocator.Allocate<UnarySDNode>();
|
||||
new (N) UnarySDNode(Opcode, DL, VTList, Ops[0]);
|
||||
N = new (NodeAllocator) UnarySDNode(Opcode, DL, VTList, Ops[0]);
|
||||
} else if (NumOps == 2) {
|
||||
N = NodeAllocator.Allocate<BinarySDNode>();
|
||||
new (N) BinarySDNode(Opcode, DL, VTList, Ops[0], Ops[1]);
|
||||
N = new (NodeAllocator) BinarySDNode(Opcode, DL, VTList, Ops[0], Ops[1]);
|
||||
} else if (NumOps == 3) {
|
||||
N = NodeAllocator.Allocate<TernarySDNode>();
|
||||
new (N) TernarySDNode(Opcode, DL, VTList, Ops[0], Ops[1], Ops[2]);
|
||||
N = new (NodeAllocator) TernarySDNode(Opcode, DL, VTList, Ops[0], Ops[1],
|
||||
Ops[2]);
|
||||
} else {
|
||||
N = NodeAllocator.Allocate<SDNode>();
|
||||
new (N) SDNode(Opcode, DL, VTList, Ops, NumOps);
|
||||
N = new (NodeAllocator) SDNode(Opcode, DL, VTList, Ops, NumOps);
|
||||
}
|
||||
CSEMap.InsertNode(N, IP);
|
||||
} else {
|
||||
if (NumOps == 1) {
|
||||
N = NodeAllocator.Allocate<UnarySDNode>();
|
||||
new (N) UnarySDNode(Opcode, DL, VTList, Ops[0]);
|
||||
N = new (NodeAllocator) UnarySDNode(Opcode, DL, VTList, Ops[0]);
|
||||
} else if (NumOps == 2) {
|
||||
N = NodeAllocator.Allocate<BinarySDNode>();
|
||||
new (N) BinarySDNode(Opcode, DL, VTList, Ops[0], Ops[1]);
|
||||
N = new (NodeAllocator) BinarySDNode(Opcode, DL, VTList, Ops[0], Ops[1]);
|
||||
} else if (NumOps == 3) {
|
||||
N = NodeAllocator.Allocate<TernarySDNode>();
|
||||
new (N) TernarySDNode(Opcode, DL, VTList, Ops[0], Ops[1], Ops[2]);
|
||||
N = new (NodeAllocator) TernarySDNode(Opcode, DL, VTList, Ops[0], Ops[1],
|
||||
Ops[2]);
|
||||
} else {
|
||||
N = NodeAllocator.Allocate<SDNode>();
|
||||
new (N) SDNode(Opcode, DL, VTList, Ops, NumOps);
|
||||
N = new (NodeAllocator) SDNode(Opcode, DL, VTList, Ops, NumOps);
|
||||
}
|
||||
}
|
||||
AllNodes.push_back(N);
|
||||
@ -4640,7 +4613,7 @@ SDNode *SelectionDAG::MorphNodeTo(SDNode *N, unsigned Opc,
|
||||
// remainder of the current SelectionDAG iteration, so we can allocate
|
||||
// the operands directly out of a pool with no recycling metadata.
|
||||
MN->InitOperands(OperandAllocator.Allocate<SDUse>(NumOps),
|
||||
Ops, NumOps);
|
||||
Ops, NumOps);
|
||||
else
|
||||
MN->InitOperands(MN->LocalOperands, Ops, NumOps);
|
||||
MN->OperandsNeedDelete = false;
|
||||
@ -4814,8 +4787,7 @@ SelectionDAG::getMachineNode(unsigned Opcode, DebugLoc DL, SDVTList VTs,
|
||||
}
|
||||
|
||||
// Allocate a new MachineSDNode.
|
||||
N = NodeAllocator.Allocate<MachineSDNode>();
|
||||
new (N) MachineSDNode(~Opcode, DL, VTs);
|
||||
N = new (NodeAllocator) MachineSDNode(~Opcode, DL, VTs);
|
||||
|
||||
// Initialize the operands list.
|
||||
if (NumOps > array_lengthof(N->LocalOperands))
|
||||
|
||||
Loading…
Reference in New Issue
Block a user