RPCSX/llvm
1
0
Fork 0
mirror of https://github.com/RPCSX/llvm.git synced 2025-02-22 05:51:42 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

InsertValue and ExtractValue constant expressions are always

Browse Source 
folded. Remove code that handled the case where they aren't
folded, and remove bitcode reader/writer support for them.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@53887 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Dan Gohman 2008-07-21 23:30:30 +00:00
parent 6e7775f732
commit e089160d10
4 changed files with 7 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/llvm/Bitcode/LLVMBitCodes.h
View File

@ -125,9 +125,7 @@ namespace bitc {
CST_CODE_CE_INSERTELT = 15, // CE_INSERTELT: [opval, opval, opval]
CST_CODE_CE_SHUFFLEVEC = 16, // CE_SHUFFLEVEC: [opval, opval, opval]
CST_CODE_CE_CMP = 17, // CE_CMP: [opty, opval, opval, pred]
CST_CODE_INLINEASM = 18, // INLINEASM: [sideeffect,asmstr,conststr]
CST_CODE_CE_EXTRACTVAL = 19, // CE_EXTRACTVAL: [n x operands]
CST_CODE_CE_INSERTVAL = 20 // CE_INSERTVAL: [n x operands]
CST_CODE_INLINEASM = 18 // INLINEASM: [sideeffect,asmstr,conststr]
};
/// CastOpcodes - These are values used in the bitcode files to encode which

41
lib/Bitcode/Reader/BitcodeReader.cpp
View File

@ -770,47 +770,6 @@ bool BitcodeReader::ParseConstants() {
V = ConstantExpr::getGetElementPtr(Elts[0], &Elts[1], Elts.size()-1);
break;
}
case bitc::CST_CODE_CE_EXTRACTVAL: {
// CE_EXTRACTVAL: [opty, opval, n x indices]
const Type *AggTy = getTypeByID(Record[0]);
if (!AggTy || !AggTy->isAggregateType())
return Error("Invalid CE_EXTRACTVAL record");
Constant *Agg = ValueList.getConstantFwdRef(Record[1], AggTy);
SmallVector<unsigned, 4> Indices;
for (unsigned i = 2, e = Record.size(); i != e; ++i) {
uint64_t Index = Record[i];
if ((unsigned)Index != Index)
return Error("Invalid CE_EXTRACTVAL record");
Indices.push_back((unsigned)Index);
}
if (!ExtractValueInst::getIndexedType(AggTy,
Indices.begin(), Indices.end()))
return Error("Invalid CE_EXTRACTVAL record");
V = ConstantExpr::getExtractValue(Agg, &Indices[0], Indices.size());
break;
}
case bitc::CST_CODE_CE_INSERTVAL: {
// CE_INSERTVAL: [opty, opval, opty, opval, n x indices]
const Type *AggTy = getTypeByID(Record[0]);
if (!AggTy || !AggTy->isAggregateType())
return Error("Invalid CE_INSERTVAL record");
Constant *Agg = ValueList.getConstantFwdRef(Record[1], AggTy);
const Type *ValTy = getTypeByID(Record[2]);
Constant *Val = ValueList.getConstantFwdRef(Record[3], ValTy);
SmallVector<unsigned, 4> Indices;
for (unsigned i = 4, e = Record.size(); i != e; ++i) {
uint64_t Index = Record[i];
if ((unsigned)Index != Index)
return Error("Invalid CE_INSERTVAL record");
Indices.push_back((unsigned)Index);
}
if (ExtractValueInst::getIndexedType(AggTy,
Indices.begin(),
Indices.end()) != ValTy)
return Error("Invalid CE_INSERTVAL record");
V = ConstantExpr::getInsertValue(Agg, Val, &Indices[0], Indices.size());
break;
}
case bitc::CST_CODE_CE_SELECT: // CE_SELECT: [opval#, opval#, opval#]
if (Record.size() < 3) return Error("Invalid CE_SELECT record");
V = ConstantExpr::getSelect(ValueList.getConstantFwdRef(Record[0],

20
lib/Bitcode/Writer/BitcodeWriter.cpp
View File

@ -611,26 +611,6 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal,
Record.push_back(VE.getValueID(C->getOperand(i)));
}
break;
case Instruction::ExtractValue: {
Code = bitc::CST_CODE_CE_EXTRACTVAL;
Record.push_back(VE.getTypeID(C->getOperand(0)->getType()));
Record.push_back(VE.getValueID(C->getOperand(0)));
const SmallVector<unsigned, 4> &Indices = CE->getIndices();
for (unsigned i = 0, e = Indices.size(); i != e; ++i)
Record.push_back(Indices[i]);
break;
}
case Instruction::InsertValue: {
Code = bitc::CST_CODE_CE_INSERTVAL;
Record.push_back(VE.getTypeID(C->getOperand(0)->getType()));
Record.push_back(VE.getValueID(C->getOperand(0)));
Record.push_back(VE.getTypeID(C->getOperand(1)->getType()));
Record.push_back(VE.getValueID(C->getOperand(1)));
const SmallVector<unsigned, 4> &Indices = CE->getIndices();
for (unsigned i = 0, e = Indices.size(); i != e; ++i)
Record.push_back(Indices[i]);
break;
}
case Instruction::Select:
Code = bitc::CST_CODE_CE_SELECT;
Record.push_back(VE.getValueID(C->getOperand(0)));

46
lib/VMCore/Constants.cpp
View File

@ -857,19 +857,6 @@ ConstantExpr::getWithOperandReplaced(unsigned OpNo, Constant *Op) const {
Op1 = (OpNo == 1) ? Op : getOperand(1);
Op2 = (OpNo == 2) ? Op : getOperand(2);
return ConstantExpr::getShuffleVector(Op0, Op1, Op2);
case Instruction::InsertValue: {
const SmallVector<unsigned, 4> &Indices = getIndices();
Op0 = (OpNo == 0) ? Op : getOperand(0);
Op1 = (OpNo == 1) ? Op : getOperand(1);
return ConstantExpr::getInsertValue(Op0, Op1,
&Indices[0], Indices.size());
}
case Instruction::ExtractValue: {
assert(OpNo == 0 && "ExtractaValue has only one operand!");
const SmallVector<unsigned, 4> &Indices = getIndices();
return
ConstantExpr::getExtractValue(Op, &Indices[0], Indices.size());
}
case Instruction::GetElementPtr: {
SmallVector<Constant*, 8> Ops;
Ops.resize(getNumOperands()-1);
@ -925,16 +912,6 @@ getWithOperands(const std::vector<Constant*> &Ops) const {
return ConstantExpr::getExtractElement(Ops[0], Ops[1]);
case Instruction::ShuffleVector:
return ConstantExpr::getShuffleVector(Ops[0], Ops[1], Ops[2]);
case Instruction::InsertValue: {
const SmallVector<unsigned, 4> &Indices = getIndices();
return ConstantExpr::getInsertValue(Ops[0], Ops[1],
&Indices[0], Indices.size());
}
case Instruction::ExtractValue: {
const SmallVector<unsigned, 4> &Indices = getIndices();
return ConstantExpr::getExtractValue(Ops[0],
&Indices[0], Indices.size());
}
case Instruction::GetElementPtr:
return ConstantExpr::getGetElementPtr(Ops[0], &Ops[1], Ops.size()-1);
case Instruction::ICmp:
@ -2365,15 +2342,9 @@ Constant *ConstantExpr::getInsertValueTy(const Type *ReqTy, Constant *Agg,
"insertvalue type invalid!");
assert(Agg->getType()->isFirstClassType() &&
"Non-first-class type for constant InsertValue expression");
if (Constant *FC = ConstantFoldInsertValueInstruction(Agg, Val, Idxs, NumIdx))
return FC; // Fold a few common cases...
// Look up the constant in the table first to ensure uniqueness
std::vector<Constant*> ArgVec;
ArgVec.push_back(Agg);
ArgVec.push_back(Val);
SmallVector<unsigned, 4> Indices(Idxs, Idxs + NumIdx);
const ExprMapKeyType Key(Instruction::InsertValue, ArgVec, 0, Indices);
return ExprConstants->getOrCreate(ReqTy, Key);
Constant *FC = ConstantFoldInsertValueInstruction(Agg, Val, Idxs, NumIdx);
assert(FC && "InsertValue constant expr couldn't be folded!");
return FC;
}
Constant *ConstantExpr::getInsertValue(Constant *Agg, Constant *Val,
@ -2395,14 +2366,9 @@ Constant *ConstantExpr::getExtractValueTy(const Type *ReqTy, Constant *Agg,
"extractvalue indices invalid!");
assert(Agg->getType()->isFirstClassType() &&
"Non-first-class type for constant extractvalue expression");
if (Constant *FC = ConstantFoldExtractValueInstruction(Agg, Idxs, NumIdx))
return FC; // Fold a few common cases...
// Look up the constant in the table first to ensure uniqueness
std::vector<Constant*> ArgVec;
ArgVec.push_back(Agg);
SmallVector<unsigned, 4> Indices(Idxs, Idxs + NumIdx);
const ExprMapKeyType Key(Instruction::ExtractValue, ArgVec, 0, Indices);
return ExprConstants->getOrCreate(ReqTy, Key);
Constant *FC = ConstantFoldExtractValueInstruction(Agg, Idxs, NumIdx);
assert(FC && "ExtractValue constant expr couldn't be folded!");
return FC;
}
Constant *ConstantExpr::getExtractValue(Constant *Agg,