replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Add a new shufflevector instruction 

llvm-svn: 27507
This commit is contained in:
Chris Lattner 2006-04-08 01:15:18 +00:00
parent 0df9c9f57d
commit c951f4c112
4 changed files with 71 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
llvm/include/llvm/Constants.h
View File

@ -524,6 +524,8 @@ protected:
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 @@ public:
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; }

7
llvm/include/llvm/Instruction.def
View File

@ -135,9 +135,10 @@ HANDLE_OTHER_INST(34, Select , SelectInst ) // select instruction
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

67
llvm/include/llvm/Instructions.h
View File

@ -733,10 +733,10 @@ class ExtractElementInst : public Instruction {
}
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 @@ class InsertElementInst : public Instruction {
}
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;
@ -810,6 +810,59 @@ public:
}
};
//===----------------------------------------------------------------------===//
// 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
//===----------------------------------------------------------------------===//

1
llvm/include/llvm/Support/InstVisitor.h
View File

@ -177,6 +177,7 @@ public:
RetTy visitVAArgInst(VAArgInst &I) { DELEGATE(Instruction); }
RetTy visitExtractElementInst(ExtractElementInst &I) { DELEGATE(Instruction); }
RetTy visitInsertElementInst(InsertElementInst &I) { DELEGATE(Instruction); }
RetTy visitShuffleVectorInst(ShuffleVectorInst &I) { DELEGATE(Instruction); }
// Next level propagators... if the user does not overload a specific
// instruction type, they can overload one of these to get the whole class