6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-15 04:30:12 +00:00
Code Issues Projects Releases Wiki Activity

Implement the two constructors in InsertValueInst and ExtractValueInst.

Browse Source 
Add a Name argment to two init methods in these classes as well to make things
a bit more consistent.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@51937 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Matthijs Kooijman 2008-06-04 14:40:55 +00:00
parent 3f32d65912
commit 444099f615
2 changed files with 62 additions and 17 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
include/llvm/Instructions.h
View File

@ -1458,8 +1458,8 @@ class ExtractValueInst : public Instruction {
SmallVector<unsigned, 4> Indices;
ExtractValueInst(const ExtractValueInst &EVI);
void init(Value *Agg, const unsigned *Idx, unsigned NumIdx);
void init(Value *Agg, unsigned Idx);
void init(Value *Agg, const unsigned *Idx, unsigned NumIdx, const std::string &Name);
void init(Value *Agg, unsigned Idx, const std::string &Name);
template<typename InputIterator>
void init(Value *Agg, InputIterator IdxBegin, InputIterator IdxEnd,
@ -1476,10 +1476,8 @@ class ExtractValueInst : public Instruction {
assert(NumIdx > 0 && "ExtractValueInst must have at least one index");
// This requires that the iterator points to contiguous memory.
init(Agg, &*IdxBegin, NumIdx); // FIXME: for the general case
// we have to build an array here
setName(Name);
init(Agg, &*IdxBegin, NumIdx, Name); // FIXME: for the general case
// we have to build an array here
}
/// getIndexedType - Returns the type of the element that would be extracted
@ -1667,8 +1665,8 @@ class InsertValueInst : public Instruction {
void *operator new(size_t, unsigned); // Do not implement
InsertValueInst(const InsertValueInst &IVI);
void init(Value *Agg, Value *Val, const unsigned *Idx, unsigned NumIdx);
void init(Value *Agg, Value *Val, unsigned Idx);
void init(Value *Agg, Value *Val, const unsigned *Idx, unsigned NumIdx, const std::string &Name);
void init(Value *Agg, Value *Val, unsigned Idx, const std::string &Name);
template<typename InputIterator>
void init(Value *Agg, Value *Val,
@ -1686,10 +1684,8 @@ class InsertValueInst : public Instruction {
assert(NumIdx > 0 && "InsertValueInst must have at least one index");
// This requires that the iterator points to contiguous memory.
init(Agg, Val, &*IdxBegin, NumIdx); // FIXME: for the general case
// we have to build an array here
setName(Name);
init(Agg, Val, &*IdxBegin, NumIdx, Name); // FIXME: for the general case
// we have to build an array here
}
/// Constructors - Create a insertvalue instruction with a base aggregate

59
lib/VMCore/Instructions.cpp
View File

@ -1350,21 +1350,24 @@ int ShuffleVectorInst::getMaskValue(unsigned i) const {
// InsertValueInst Class
//===----------------------------------------------------------------------===//
void InsertValueInst::init(Value *Agg, Value *Val,
const unsigned *Idx, unsigned NumIdx) {
void InsertValueInst::init(Value *Agg, Value *Val, const unsigned *Idx,
unsigned NumIdx, const std::string &Name) {
assert(NumOperands == 2 && "NumOperands not initialized?");
Op<0>() = Agg;
Op<1>() = Val;
Indices.insert(Indices.end(), Idx, Idx + NumIdx);
setName(Name);
}
void InsertValueInst::init(Value *Agg, Value *Val, unsigned Idx) {
void InsertValueInst::init(Value *Agg, Value *Val, unsigned Idx,
const std::string &Name) {
assert(NumOperands == 2 && "NumOperands not initialized?");
Op<0>() = Agg;
Op<1>() = Val;
Indices.push_back(Idx);
setName(Name);
}
InsertValueInst::InsertValueInst(const InsertValueInst &IVI)
@ -1373,22 +1376,46 @@ InsertValueInst::InsertValueInst(const InsertValueInst &IVI)
Indices(IVI.Indices) {
}
InsertValueInst::InsertValueInst(Value *Agg,
Value *Val,
unsigned Idx,
const std::string &Name,
Instruction *InsertBefore)
: Instruction(Agg->getType(), InsertValue,
OperandTraits<InsertValueInst>::op_begin(this),
2, InsertBefore) {
init(Agg, Val, Idx, Name);
}
InsertValueInst::InsertValueInst(Value *Agg,
Value *Val,
unsigned Idx,
const std::string &Name,
BasicBlock *InsertAtEnd)
: Instruction(Agg->getType(), InsertValue,
OperandTraits<InsertValueInst>::op_begin(this),
2, InsertAtEnd) {
init(Agg, Val, Idx, Name);
}
//===----------------------------------------------------------------------===//
// ExtractValueInst Class
//===----------------------------------------------------------------------===//
void ExtractValueInst::init(Value *Agg, const unsigned *Idx, unsigned NumIdx) {
void ExtractValueInst::init(Value *Agg, const unsigned *Idx, unsigned NumIdx, const std::string &Name) {
assert(NumOperands == 1 && "NumOperands not initialized?");
Op<0>() = Agg;
Indices.insert(Indices.end(), Idx, Idx + NumIdx);
setName(Name);
}
void ExtractValueInst::init(Value *Agg, unsigned Idx) {
void ExtractValueInst::init(Value *Agg, unsigned Idx, const std::string &Name) {
assert(NumOperands == 1 && "NumOperands not initialized?");
Op<0>() = Agg;
Indices.push_back(Idx);
setName(Name);
}
ExtractValueInst::ExtractValueInst(const ExtractValueInst &EVI)
@ -1424,6 +1451,28 @@ const Type* ExtractValueInst::getIndexedType(const Type *Agg,
return CurIdx == NumIdx ? Agg : 0;
}
ExtractValueInst::ExtractValueInst(Value *Agg,
unsigned Idx,
const std::string &Name,
BasicBlock *InsertAtEnd)
: Instruction(checkType(getIndexedType(Agg->getType(), &Idx, 1)),
ExtractValue,
OperandTraits<ExtractValueInst>::op_begin(this),
1, InsertAtEnd) {
init(Agg, Idx, Name);
}
ExtractValueInst::ExtractValueInst(Value *Agg,
unsigned Idx,
const std::string &Name,
Instruction *InsertBefore)
: Instruction(checkType(getIndexedType(Agg->getType(), &Idx, 1)),
ExtractValue,
OperandTraits<ExtractValueInst>::op_begin(this),
1, InsertBefore) {
init(Agg, Idx, Name);
}
//===----------------------------------------------------------------------===//
// BinaryOperator Class
//===----------------------------------------------------------------------===//