const char *SelectInst::areInvalidOperands(Value *Op0, Value *Op1, Value *Op2) {
if (Op1->getType() != Op2->getType())
return "both values to select must have same type";
-
+
+ if (Op1->getType()->isTokenTy())
+ return "select values cannot have token type";
+
if (VectorType *VT = dyn_cast<VectorType>(Op0->getType())) {
// Vector select.
if (VT->getElementType() != Type::getInt1Ty(Op0->getContext()))
CRI.getNumOperands(),
CRI.getNumOperands()) {
SubclassOptionalData = CRI.SubclassOptionalData;
- if (Value *RetVal = CRI.getReturnValue())
- setReturnValue(RetVal);
- if (BasicBlock *UnwindDest = CRI.getUnwindDest())
- setUnwindDest(UnwindDest);
+ setInstructionSubclassData(CRI.getSubclassDataFromInstruction());
+ Op<-1>() = CRI.Op<-1>();
+ if (CRI.hasUnwindDest())
+ Op<-2>() = CRI.Op<-2>();
}
-void CleanupReturnInst::init(Value *RetVal, BasicBlock *UnwindBB) {
+void CleanupReturnInst::init(CleanupPadInst *CleanupPad, BasicBlock *UnwindBB) {
SubclassOptionalData = 0;
if (UnwindBB)
setInstructionSubclassData(getSubclassDataFromInstruction() | 1);
- if (RetVal)
- setInstructionSubclassData(getSubclassDataFromInstruction() | 2);
+ Op<-1>() = CleanupPad;
if (UnwindBB)
- setUnwindDest(UnwindBB);
- if (RetVal)
- setReturnValue(RetVal);
+ Op<-2>() = UnwindBB;
}
-CleanupReturnInst::CleanupReturnInst(LLVMContext &C, Value *RetVal,
+CleanupReturnInst::CleanupReturnInst(CleanupPadInst *CleanupPad,
BasicBlock *UnwindBB, unsigned Values,
Instruction *InsertBefore)
- : TerminatorInst(Type::getVoidTy(C), Instruction::CleanupRet,
+ : TerminatorInst(Type::getVoidTy(CleanupPad->getContext()),
+ Instruction::CleanupRet,
OperandTraits<CleanupReturnInst>::op_end(this) - Values,
Values, InsertBefore) {
- init(RetVal, UnwindBB);
+ init(CleanupPad, UnwindBB);
}
-CleanupReturnInst::CleanupReturnInst(LLVMContext &C, Value *RetVal,
+CleanupReturnInst::CleanupReturnInst(CleanupPadInst *CleanupPad,
BasicBlock *UnwindBB, unsigned Values,
BasicBlock *InsertAtEnd)
- : TerminatorInst(Type::getVoidTy(C), Instruction::CleanupRet,
+ : TerminatorInst(Type::getVoidTy(CleanupPad->getContext()),
+ Instruction::CleanupRet,
OperandTraits<CleanupReturnInst>::op_end(this) - Values,
Values, InsertAtEnd) {
- init(RetVal, UnwindBB);
-}
-
-BasicBlock *CleanupReturnInst::getUnwindDest() const {
- if (hasUnwindDest())
- return cast<BasicBlock>(getOperand(getUnwindLabelOpIdx()));
- return nullptr;
-}
-void CleanupReturnInst::setUnwindDest(BasicBlock *NewDest) {
- assert(NewDest);
- setOperand(getUnwindLabelOpIdx(), NewDest);
+ init(CleanupPad, UnwindBB);
}
BasicBlock *CleanupReturnInst::getSuccessorV(unsigned Idx) const {
}
//===----------------------------------------------------------------------===//
-// CatchEndBlockInst Implementation
+// CatchEndPadInst Implementation
//===----------------------------------------------------------------------===//
-CatchEndBlockInst::CatchEndBlockInst(const CatchEndBlockInst &CRI)
- : TerminatorInst(CRI.getType(), Instruction::CatchEndBlock,
- OperandTraits<CatchEndBlockInst>::op_end(this) -
+CatchEndPadInst::CatchEndPadInst(const CatchEndPadInst &CRI)
+ : TerminatorInst(CRI.getType(), Instruction::CatchEndPad,
+ OperandTraits<CatchEndPadInst>::op_end(this) -
CRI.getNumOperands(),
CRI.getNumOperands()) {
SubclassOptionalData = CRI.SubclassOptionalData;
+ setInstructionSubclassData(CRI.getSubclassDataFromInstruction());
if (BasicBlock *UnwindDest = CRI.getUnwindDest())
setUnwindDest(UnwindDest);
}
-void CatchEndBlockInst::init(BasicBlock *UnwindBB) {
+void CatchEndPadInst::init(BasicBlock *UnwindBB) {
SubclassOptionalData = 0;
if (UnwindBB) {
setInstructionSubclassData(getSubclassDataFromInstruction() | 1);
}
}
-CatchEndBlockInst::CatchEndBlockInst(LLVMContext &C, BasicBlock *UnwindBB,
- unsigned Values, Instruction *InsertBefore)
- : TerminatorInst(Type::getVoidTy(C), Instruction::CatchEndBlock,
- OperandTraits<CatchEndBlockInst>::op_end(this) - Values,
+CatchEndPadInst::CatchEndPadInst(LLVMContext &C, BasicBlock *UnwindBB,
+ unsigned Values, Instruction *InsertBefore)
+ : TerminatorInst(Type::getVoidTy(C), Instruction::CatchEndPad,
+ OperandTraits<CatchEndPadInst>::op_end(this) - Values,
Values, InsertBefore) {
init(UnwindBB);
}
-CatchEndBlockInst::CatchEndBlockInst(LLVMContext &C, BasicBlock *UnwindBB,
- unsigned Values, BasicBlock *InsertAtEnd)
- : TerminatorInst(Type::getVoidTy(C), Instruction::CatchEndBlock,
- OperandTraits<CatchEndBlockInst>::op_end(this) - Values,
+CatchEndPadInst::CatchEndPadInst(LLVMContext &C, BasicBlock *UnwindBB,
+ unsigned Values, BasicBlock *InsertAtEnd)
+ : TerminatorInst(Type::getVoidTy(C), Instruction::CatchEndPad,
+ OperandTraits<CatchEndPadInst>::op_end(this) - Values,
Values, InsertAtEnd) {
init(UnwindBB);
}
-BasicBlock *CatchEndBlockInst::getSuccessorV(unsigned Idx) const {
+BasicBlock *CatchEndPadInst::getSuccessorV(unsigned Idx) const {
assert(Idx == 0);
return getUnwindDest();
}
-unsigned CatchEndBlockInst::getNumSuccessorsV() const {
+unsigned CatchEndPadInst::getNumSuccessorsV() const {
return getNumSuccessors();
}
-void CatchEndBlockInst::setSuccessorV(unsigned Idx, BasicBlock *B) {
+void CatchEndPadInst::setSuccessorV(unsigned Idx, BasicBlock *B) {
assert(Idx == 0);
setUnwindDest(B);
}
//===----------------------------------------------------------------------===//
// CatchReturnInst Implementation
//===----------------------------------------------------------------------===//
+void CatchReturnInst::init(CatchPadInst *CatchPad, BasicBlock *BB) {
+ Op<0>() = CatchPad;
+ Op<1>() = BB;
+}
CatchReturnInst::CatchReturnInst(const CatchReturnInst &CRI)
: TerminatorInst(Type::getVoidTy(CRI.getContext()), Instruction::CatchRet,
- OperandTraits<CatchReturnInst>::op_end(this) -
- CRI.getNumOperands(),
- CRI.getNumOperands()) {
+ OperandTraits<CatchReturnInst>::op_begin(this), 2) {
Op<0>() = CRI.Op<0>();
+ Op<1>() = CRI.Op<1>();
}
-CatchReturnInst::CatchReturnInst(BasicBlock *BB, Instruction *InsertBefore)
+CatchReturnInst::CatchReturnInst(CatchPadInst *CatchPad, BasicBlock *BB,
+ Instruction *InsertBefore)
: TerminatorInst(Type::getVoidTy(BB->getContext()), Instruction::CatchRet,
- OperandTraits<CatchReturnInst>::op_begin(this), 1,
+ OperandTraits<CatchReturnInst>::op_begin(this), 2,
InsertBefore) {
- Op<0>() = BB;
+ init(CatchPad, BB);
}
-CatchReturnInst::CatchReturnInst(BasicBlock *BB, BasicBlock *InsertAtEnd)
+CatchReturnInst::CatchReturnInst(CatchPadInst *CatchPad, BasicBlock *BB,
+ BasicBlock *InsertAtEnd)
: TerminatorInst(Type::getVoidTy(BB->getContext()), Instruction::CatchRet,
- OperandTraits<CatchReturnInst>::op_begin(this), 1,
+ OperandTraits<CatchReturnInst>::op_begin(this), 2,
InsertAtEnd) {
- Op<0>() = BB;
+ init(CatchPad, BB);
}
BasicBlock *CatchReturnInst::getSuccessorV(unsigned Idx) const {
}
//===----------------------------------------------------------------------===//
-// CatchBlockInst Implementation
+// CatchPadInst Implementation
//===----------------------------------------------------------------------===//
-void CatchBlockInst::init(BasicBlock *IfNormal, BasicBlock *IfException,
- ArrayRef<Value *> Args, const Twine &NameStr) {
+void CatchPadInst::init(BasicBlock *IfNormal, BasicBlock *IfException,
+ ArrayRef<Value *> Args, const Twine &NameStr) {
assert(getNumOperands() == 2 + Args.size() && "NumOperands not set up?");
Op<-2>() = IfNormal;
Op<-1>() = IfException;
setName(NameStr);
}
-CatchBlockInst::CatchBlockInst(const CatchBlockInst &CBI)
- : TerminatorInst(CBI.getType(), Instruction::CatchBlock,
- OperandTraits<CatchBlockInst>::op_end(this) -
- CBI.getNumOperands(),
- CBI.getNumOperands()) {
- std::copy(CBI.op_begin(), CBI.op_end(), op_begin());
+CatchPadInst::CatchPadInst(const CatchPadInst &CPI)
+ : TerminatorInst(CPI.getType(), Instruction::CatchPad,
+ OperandTraits<CatchPadInst>::op_end(this) -
+ CPI.getNumOperands(),
+ CPI.getNumOperands()) {
+ std::copy(CPI.op_begin(), CPI.op_end(), op_begin());
}
-CatchBlockInst::CatchBlockInst(Type *RetTy, BasicBlock *IfNormal,
- BasicBlock *IfException, ArrayRef<Value *> Args,
- unsigned Values, const Twine &NameStr,
- Instruction *InsertBefore)
- : TerminatorInst(RetTy, Instruction::CatchBlock,
- OperandTraits<CatchBlockInst>::op_end(this) - Values,
- Values, InsertBefore) {
+CatchPadInst::CatchPadInst(BasicBlock *IfNormal, BasicBlock *IfException,
+ ArrayRef<Value *> Args, unsigned Values,
+ const Twine &NameStr, Instruction *InsertBefore)
+ : TerminatorInst(Type::getTokenTy(IfNormal->getContext()),
+ Instruction::CatchPad,
+ OperandTraits<CatchPadInst>::op_end(this) - Values, Values,
+ InsertBefore) {
init(IfNormal, IfException, Args, NameStr);
}
-CatchBlockInst::CatchBlockInst(Type *RetTy, BasicBlock *IfNormal,
- BasicBlock *IfException, ArrayRef<Value *> Args,
- unsigned Values, const Twine &NameStr,
- BasicBlock *InsertAtEnd)
- : TerminatorInst(RetTy, Instruction::CatchBlock,
- OperandTraits<CatchBlockInst>::op_end(this) - Values,
- Values, InsertAtEnd) {
+CatchPadInst::CatchPadInst(BasicBlock *IfNormal, BasicBlock *IfException,
+ ArrayRef<Value *> Args, unsigned Values,
+ const Twine &NameStr, BasicBlock *InsertAtEnd)
+ : TerminatorInst(Type::getTokenTy(IfNormal->getContext()),
+ Instruction::CatchPad,
+ OperandTraits<CatchPadInst>::op_end(this) - Values, Values,
+ InsertAtEnd) {
init(IfNormal, IfException, Args, NameStr);
}
-BasicBlock *CatchBlockInst::getSuccessorV(unsigned Idx) const {
+BasicBlock *CatchPadInst::getSuccessorV(unsigned Idx) const {
return getSuccessor(Idx);
}
-unsigned CatchBlockInst::getNumSuccessorsV() const {
+unsigned CatchPadInst::getNumSuccessorsV() const {
return getNumSuccessors();
}
-void CatchBlockInst::setSuccessorV(unsigned Idx, BasicBlock *B) {
+void CatchPadInst::setSuccessorV(unsigned Idx, BasicBlock *B) {
return setSuccessor(Idx, B);
}
//===----------------------------------------------------------------------===//
-// TerminateBlockInst Implementation
+// TerminatePadInst Implementation
//===----------------------------------------------------------------------===//
-void TerminateBlockInst::init(BasicBlock *BB, ArrayRef<Value *> Args,
- const Twine &NameStr) {
+void TerminatePadInst::init(BasicBlock *BB, ArrayRef<Value *> Args) {
SubclassOptionalData = 0;
if (BB)
setInstructionSubclassData(getSubclassDataFromInstruction() | 1);
if (BB)
Op<-1>() = BB;
std::copy(Args.begin(), Args.end(), op_begin());
- setName(NameStr);
}
-TerminateBlockInst::TerminateBlockInst(const TerminateBlockInst &TBI)
- : TerminatorInst(TBI.getType(), Instruction::TerminateBlock,
- OperandTraits<TerminateBlockInst>::op_end(this) -
- TBI.getNumOperands(),
- TBI.getNumOperands()) {
- SubclassOptionalData = TBI.SubclassOptionalData;
- std::copy(TBI.op_begin(), TBI.op_end(), op_begin());
+TerminatePadInst::TerminatePadInst(const TerminatePadInst &TPI)
+ : TerminatorInst(TPI.getType(), Instruction::TerminatePad,
+ OperandTraits<TerminatePadInst>::op_end(this) -
+ TPI.getNumOperands(),
+ TPI.getNumOperands()) {
+ SubclassOptionalData = TPI.SubclassOptionalData;
+ setInstructionSubclassData(TPI.getSubclassDataFromInstruction());
+ std::copy(TPI.op_begin(), TPI.op_end(), op_begin());
}
-TerminateBlockInst::TerminateBlockInst(LLVMContext &C, BasicBlock *BB,
- ArrayRef<Value *> Args, unsigned Values,
- const Twine &NameStr,
- Instruction *InsertBefore)
- : TerminatorInst(Type::getVoidTy(C), Instruction::TerminateBlock,
- OperandTraits<TerminateBlockInst>::op_end(this) - Values,
+TerminatePadInst::TerminatePadInst(LLVMContext &C, BasicBlock *BB,
+ ArrayRef<Value *> Args, unsigned Values,
+ Instruction *InsertBefore)
+ : TerminatorInst(Type::getVoidTy(C), Instruction::TerminatePad,
+ OperandTraits<TerminatePadInst>::op_end(this) - Values,
Values, InsertBefore) {
- init(BB, Args, NameStr);
+ init(BB, Args);
}
-TerminateBlockInst::TerminateBlockInst(LLVMContext &C, BasicBlock *BB,
- ArrayRef<Value *> Args, unsigned Values,
- const Twine &NameStr,
- BasicBlock *InsertAtEnd)
- : TerminatorInst(Type::getVoidTy(C), Instruction::TerminateBlock,
- OperandTraits<TerminateBlockInst>::op_end(this) - Values,
+TerminatePadInst::TerminatePadInst(LLVMContext &C, BasicBlock *BB,
+ ArrayRef<Value *> Args, unsigned Values,
+ BasicBlock *InsertAtEnd)
+ : TerminatorInst(Type::getVoidTy(C), Instruction::TerminatePad,
+ OperandTraits<TerminatePadInst>::op_end(this) - Values,
Values, InsertAtEnd) {
- init(BB, Args, NameStr);
+ init(BB, Args);
}
-BasicBlock *TerminateBlockInst::getSuccessorV(unsigned Idx) const {
+BasicBlock *TerminatePadInst::getSuccessorV(unsigned Idx) const {
assert(Idx == 0);
return getUnwindDest();
}
-unsigned TerminateBlockInst::getNumSuccessorsV() const {
+unsigned TerminatePadInst::getNumSuccessorsV() const {
return getNumSuccessors();
}
-void TerminateBlockInst::setSuccessorV(unsigned Idx, BasicBlock *B) {
+void TerminatePadInst::setSuccessorV(unsigned Idx, BasicBlock *B) {
assert(Idx == 0);
return setUnwindDest(B);
}
//===----------------------------------------------------------------------===//
-// CleanupBlockInst Implementation
+// CleanupPadInst Implementation
//===----------------------------------------------------------------------===//
-void CleanupBlockInst::init(ArrayRef<Value *> Args, const Twine &NameStr) {
+void CleanupPadInst::init(ArrayRef<Value *> Args, const Twine &NameStr) {
assert(getNumOperands() == Args.size() && "NumOperands not set up?");
std::copy(Args.begin(), Args.end(), op_begin());
setName(NameStr);
}
-CleanupBlockInst::CleanupBlockInst(const CleanupBlockInst &CBI)
- : Instruction(CBI.getType(), Instruction::CleanupBlock,
- OperandTraits<CleanupBlockInst>::op_end(this) -
- CBI.getNumOperands(),
- CBI.getNumOperands()) {
- std::copy(CBI.op_begin(), CBI.op_end(), op_begin());
+CleanupPadInst::CleanupPadInst(const CleanupPadInst &CPI)
+ : Instruction(CPI.getType(), Instruction::CleanupPad,
+ OperandTraits<CleanupPadInst>::op_end(this) -
+ CPI.getNumOperands(),
+ CPI.getNumOperands()) {
+ std::copy(CPI.op_begin(), CPI.op_end(), op_begin());
}
-CleanupBlockInst::CleanupBlockInst(Type *RetTy, ArrayRef<Value *> Args,
- const Twine &NameStr,
- Instruction *InsertBefore)
- : Instruction(RetTy, Instruction::CleanupBlock,
- OperandTraits<CleanupBlockInst>::op_end(this) - Args.size(),
+CleanupPadInst::CleanupPadInst(LLVMContext &C, ArrayRef<Value *> Args,
+ const Twine &NameStr, Instruction *InsertBefore)
+ : Instruction(Type::getTokenTy(C), Instruction::CleanupPad,
+ OperandTraits<CleanupPadInst>::op_end(this) - Args.size(),
Args.size(), InsertBefore) {
init(Args, NameStr);
}
-CleanupBlockInst::CleanupBlockInst(Type *RetTy, ArrayRef<Value *> Args,
- const Twine &NameStr,
- BasicBlock *InsertAtEnd)
- : Instruction(RetTy, Instruction::CleanupBlock,
- OperandTraits<CleanupBlockInst>::op_end(this) - Args.size(),
+CleanupPadInst::CleanupPadInst(LLVMContext &C, ArrayRef<Value *> Args,
+ const Twine &NameStr, BasicBlock *InsertAtEnd)
+ : Instruction(Type::getTokenTy(C), Instruction::CleanupPad,
+ OperandTraits<CleanupPadInst>::op_end(this) - Args.size(),
Args.size(), InsertAtEnd) {
init(Args, NameStr);
}
return new (getNumOperands()) CleanupReturnInst(*this);
}
-CatchEndBlockInst *CatchEndBlockInst::cloneImpl() const {
- return new (getNumOperands()) CatchEndBlockInst(*this);
+CatchEndPadInst *CatchEndPadInst::cloneImpl() const {
+ return new (getNumOperands()) CatchEndPadInst(*this);
}
CatchReturnInst *CatchReturnInst::cloneImpl() const {
- return new (1) CatchReturnInst(*this);
+ return new (getNumOperands()) CatchReturnInst(*this);
}
-CatchBlockInst *CatchBlockInst::cloneImpl() const {
- return new (getNumOperands()) CatchBlockInst(*this);
+CatchPadInst *CatchPadInst::cloneImpl() const {
+ return new (getNumOperands()) CatchPadInst(*this);
}
-TerminateBlockInst *TerminateBlockInst::cloneImpl() const {
- return new (getNumOperands()) TerminateBlockInst(*this);
+TerminatePadInst *TerminatePadInst::cloneImpl() const {
+ return new (getNumOperands()) TerminatePadInst(*this);
}
-CleanupBlockInst *CleanupBlockInst::cloneImpl() const {
- return new (getNumOperands()) CleanupBlockInst(*this);
+CleanupPadInst *CleanupPadInst::cloneImpl() const {
+ return new (getNumOperands()) CleanupPadInst(*this);
}
UnreachableInst *UnreachableInst::cloneImpl() const {
projects / oota-llvm.git / blobdiff