+const Type* GetElementPtrInst::getIndexedType(const Type *Ptr, Value *Idx) {
+ const PointerType *PTy = dyn_cast<PointerType>(Ptr);
+ if (!PTy) return 0; // Type isn't a pointer type!
+
+ // Check the pointer index.
+ if (!PTy->indexValid(Idx)) return 0;
+
+ return PTy->getElementType();
+}
+
+//===----------------------------------------------------------------------===//
+// ExtractElementInst Implementation
+//===----------------------------------------------------------------------===//
+
+ExtractElementInst::ExtractElementInst(Value *Val, Value *Index,
+ const std::string &Name,
+ Instruction *InsertBef)
+ : Instruction(cast<PackedType>(Val->getType())->getElementType(),
+ ExtractElement, Ops, 2, Name, InsertBef) {
+ assert(isValidOperands(Val, Index) &&
+ "Invalid extractelement instruction operands!");
+ Ops[0].init(Val, this);
+ Ops[1].init(Index, this);
+}
+
+ExtractElementInst::ExtractElementInst(Value *Val, Value *Index,
+ const std::string &Name,
+ BasicBlock *InsertAE)
+ : Instruction(cast<PackedType>(Val->getType())->getElementType(),
+ ExtractElement, Ops, 2, Name, InsertAE) {
+ assert(isValidOperands(Val, Index) &&
+ "Invalid extractelement instruction operands!");
+
+ Ops[0].init(Val, this);
+ Ops[1].init(Index, this);
+}
+
+bool ExtractElementInst::isValidOperands(const Value *Val, const Value *Index) {
+ if (!isa<PackedType>(Val->getType()) || Index->getType() != Type::UIntTy)
+ return false;
+ return true;
+}
+
+
+//===----------------------------------------------------------------------===//
+// InsertElementInst Implementation
+//===----------------------------------------------------------------------===//
+
+InsertElementInst::InsertElementInst(const InsertElementInst &IE)
+ : Instruction(IE.getType(), InsertElement, Ops, 3) {
+ Ops[0].init(IE.Ops[0], this);
+ Ops[1].init(IE.Ops[1], this);
+ Ops[2].init(IE.Ops[2], this);
+}
+InsertElementInst::InsertElementInst(Value *Vec, Value *Elt, Value *Index,
+ const std::string &Name,
+ Instruction *InsertBef)
+ : Instruction(Vec->getType(), InsertElement, Ops, 3, Name, InsertBef) {
+ assert(isValidOperands(Vec, Elt, Index) &&
+ "Invalid insertelement instruction operands!");
+ Ops[0].init(Vec, this);
+ Ops[1].init(Elt, this);
+ Ops[2].init(Index, this);
+}
+
+InsertElementInst::InsertElementInst(Value *Vec, Value *Elt, Value *Index,
+ const std::string &Name,
+ BasicBlock *InsertAE)
+ : Instruction(Vec->getType(), InsertElement, Ops, 3, Name, InsertAE) {
+ assert(isValidOperands(Vec, Elt, Index) &&
+ "Invalid insertelement instruction operands!");
+
+ Ops[0].init(Vec, this);
+ Ops[1].init(Elt, this);
+ Ops[2].init(Index, this);
+}
+
+bool InsertElementInst::isValidOperands(const Value *Vec, const Value *Elt,
+ const Value *Index) {
+ if (!isa<PackedType>(Vec->getType()))
+ return false; // First operand of insertelement must be packed type.
+
+ if (Elt->getType() != cast<PackedType>(Vec->getType())->getElementType())
+ return false;// Second operand of insertelement must be packed element type.
+
+ if (Index->getType() != Type::UIntTy)
+ return false; // Third operand of insertelement must be uint.
+ return true;
+}
+
+
+//===----------------------------------------------------------------------===//
+// ShuffleVectorInst Implementation
+//===----------------------------------------------------------------------===//
+
+ShuffleVectorInst::ShuffleVectorInst(const ShuffleVectorInst &SV)
+ : Instruction(SV.getType(), ShuffleVector, Ops, 3) {
+ Ops[0].init(SV.Ops[0], this);
+ Ops[1].init(SV.Ops[1], this);
+ Ops[2].init(SV.Ops[2], this);
+}
+
+ShuffleVectorInst::ShuffleVectorInst(Value *V1, Value *V2, Value *Mask,
+ const std::string &Name,
+ Instruction *InsertBefore)
+ : Instruction(V1->getType(), ShuffleVector, Ops, 3, Name, InsertBefore) {
+ assert(isValidOperands(V1, V2, Mask) &&
+ "Invalid shuffle vector instruction operands!");
+ Ops[0].init(V1, this);
+ Ops[1].init(V2, this);
+ Ops[2].init(Mask, this);
+}
+
+ShuffleVectorInst::ShuffleVectorInst(Value *V1, Value *V2, Value *Mask,
+ const std::string &Name,
+ BasicBlock *InsertAtEnd)
+ : Instruction(V1->getType(), ShuffleVector, Ops, 3, Name, InsertAtEnd) {
+ assert(isValidOperands(V1, V2, Mask) &&
+ "Invalid shuffle vector instruction operands!");
+
+ Ops[0].init(V1, this);
+ Ops[1].init(V2, this);
+ Ops[2].init(Mask, this);
+}
+
+bool ShuffleVectorInst::isValidOperands(const Value *V1, const Value *V2,
+ const Value *Mask) {
+ if (!isa<PackedType>(V1->getType())) return false;
+ if (V1->getType() != V2->getType()) return false;
+ if (!isa<PackedType>(Mask->getType()) ||
+ cast<PackedType>(Mask->getType())->getElementType() != Type::UIntTy ||
+ cast<PackedType>(Mask->getType())->getNumElements() !=
+ cast<PackedType>(V1->getType())->getNumElements())
+ return false;
+ return true;
+}
+
+