Changes in directory llvm/include/llvm:
Constants.h updated: 1.78 -> 1.79 Instruction.def updated: 1.18 -> 1.19 Instructions.h updated: 1.31 -> 1.32 --- Log message: Add a new shufflevector instruction --- Diffs of the changes: (+70 -19) Constants.h | 15 +++++------- Instruction.def | 7 +++-- Instructions.h | 67 ++++++++++++++++++++++++++++++++++++++++++++++++++------ 3 files changed, 70 insertions(+), 19 deletions(-) Index: llvm/include/llvm/Constants.h diff -u llvm/include/llvm/Constants.h:1.78 llvm/include/llvm/Constants.h:1.79 --- llvm/include/llvm/Constants.h:1.78 Tue Feb 7 00:17:10 2006 +++ llvm/include/llvm/Constants.h Fri Apr 7 20:15:18 2006 @@ -524,6 +524,8 @@ Constant *Idx); static Constant *getInsertElementTy(const Type *Ty, Constant *Val, Constant *Elt, Constant *Idx); + static Constant *getShuffleVectorTy(const Type *Ty, Constant *V1, + Constant *V2, Constant *Mask); public: // Static methods to construct a ConstantExpr of different kinds. Note that @@ -591,15 +593,10 @@ static Constant *getGetElementPtr(Constant *C, const std::vector<Value*> &IdxList); - /// Extractelement form. - /// - static Constant *getExtractElement(Constant *Val, Constant *Idx); - - /// Insertelement form. - /// - static Constant *getInsertElement(Constant *Val, Constant *Elt, - Constant *Idx); - + static Constant *getExtractElement(Constant *Vec, Constant *Idx); + static Constant *getInsertElement(Constant *Vec, Constant *Elt,Constant *Idx); + static Constant *getShuffleVector(Constant *V1, Constant *V2, Constant *Mask); + /// isNullValue - Return true if this is the value that would be returned by /// getNullValue. virtual bool isNullValue() const { return false; } Index: llvm/include/llvm/Instruction.def diff -u llvm/include/llvm/Instruction.def:1.18 llvm/include/llvm/Instruction.def:1.19 --- llvm/include/llvm/Instruction.def:1.18 Tue Jan 17 14:05:59 2006 +++ llvm/include/llvm/Instruction.def Fri Apr 7 20:15:18 2006 @@ -135,9 +135,10 @@ HANDLE_OTHER_INST(35, UserOp1, Instruction) // May be used internally in a pass HANDLE_OTHER_INST(36, UserOp2, Instruction) HANDLE_OTHER_INST(37, VAArg , VAArgInst ) // vaarg instruction -HANDLE_OTHER_INST(38, ExtractElement, ExtractElementInst) // extract packed element -HANDLE_OTHER_INST(39, InsertElement, InsertElementInst) // insert element into packed vector - LAST_OTHER_INST(39) +HANDLE_OTHER_INST(38, ExtractElement, ExtractElementInst)// extract from vector. +HANDLE_OTHER_INST(39, InsertElement, InsertElementInst) // insert into vector +HANDLE_OTHER_INST(40, ShuffleVector, ShuffleVectorInst) // shuffle two vectors. + LAST_OTHER_INST(40) #undef FIRST_TERM_INST #undef HANDLE_TERM_INST Index: llvm/include/llvm/Instructions.h diff -u llvm/include/llvm/Instructions.h:1.31 llvm/include/llvm/Instructions.h:1.32 --- llvm/include/llvm/Instructions.h:1.31 Tue Jan 17 14:05:59 2006 +++ llvm/include/llvm/Instructions.h Fri Apr 7 20:15:18 2006 @@ -733,10 +733,10 @@ } public: - ExtractElementInst(Value *Val, Value *Index, - const std::string &Name = "", Instruction *InsertBefore = 0); - ExtractElementInst(Value *Val, Value *Index, - const std::string &Name, BasicBlock *InsertAtEnd); + ExtractElementInst(Value *Vec, Value *Idx, const std::string &Name = "", + Instruction *InsertBefore = 0); + ExtractElementInst(Value *Vec, Value *Idx, const std::string &Name, + BasicBlock *InsertAtEnd); virtual ExtractElementInst *clone() const; @@ -780,9 +780,9 @@ } public: - InsertElementInst(Value *Val, Value *Elt, Value *Index, - const std::string &Name = "", Instruction *InsertBefore = 0); - InsertElementInst(Value *Val, Value *Elt, Value *Index, + InsertElementInst(Value *Vec, Value *NewElt, Value *Idx, + const std::string &Name = "",Instruction *InsertBefore = 0); + InsertElementInst(Value *Vec, Value *NewElt, Value *Idx, const std::string &Name, BasicBlock *InsertAtEnd); virtual InsertElementInst *clone() const; @@ -811,6 +811,59 @@ }; //===----------------------------------------------------------------------===// +// ShuffleVectorInst Class +//===----------------------------------------------------------------------===// + +/// ShuffleVectorInst - This instruction constructs a fixed permutation of two +/// input vectors. +/// +class ShuffleVectorInst : public Instruction { + Use Ops[3]; + ShuffleVectorInst(const ShuffleVectorInst &IE) : + Instruction(IE.getType(), ShuffleVector, Ops, 3) { + Ops[0].init(IE.Ops[0], this); + Ops[1].init(IE.Ops[1], this); + Ops[2].init(IE.Ops[2], this); + } + +public: + ShuffleVectorInst(Value *V1, Value *V2, Value *Mask, + const std::string &Name = "", Instruction *InsertBefor = 0); + ShuffleVectorInst(Value *V1, Value *V2, Value *Mask, + const std::string &Name, BasicBlock *InsertAtEnd); + + /// isValidOperands - Return true if a value shufflevector instruction can be + /// formed with the specified operands. + static bool isValidOperands(const Value *V1, const Value *V2, + const Value *Mask); + + virtual ShuffleVectorInst *clone() const; + + virtual bool mayWriteToMemory() const { return false; } + + /// Transparently provide more efficient getOperand methods. + Value *getOperand(unsigned i) const { + assert(i < 3 && "getOperand() out of range!"); + return Ops[i]; + } + void setOperand(unsigned i, Value *Val) { + assert(i < 3 && "setOperand() out of range!"); + Ops[i] = Val; + } + unsigned getNumOperands() const { return 3; } + + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const ShuffleVectorInst *) { return true; } + static inline bool classof(const Instruction *I) { + return I->getOpcode() == Instruction::ShuffleVector; + } + static inline bool classof(const Value *V) { + return isa<Instruction>(V) && classof(cast<Instruction>(V)); + } +}; + + +//===----------------------------------------------------------------------===// // PHINode Class //===----------------------------------------------------------------------===// _______________________________________________ llvm-commits mailing list llvm-commits@cs.uiuc.edu http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits