RPCSX/llvm
1
0
Fork 0
mirror of https://github.com/RPCSX/llvm.git synced 2024-12-02 00:36:36 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Previously, all operands to Constant were themselves constant.

Browse Source 
In the new world order, BlockAddress can have a BasicBlock operand.
This doesn't permute much, because if you have a ConstantExpr (or
anything more specific than Constant) we still know the operand has
to be a Constant.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@85375 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2009-10-28 05:14:34 +00:00
parent 46b3abc9f7
commit 0eeb913aa1
7 changed files with 48 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
include/llvm/Constant.h
View File

@ -48,6 +48,10 @@ protected:
: User(ty, vty, Ops, NumOps) {}
void destroyConstantImpl();
void setOperand(unsigned i, Value *V) {
User::setOperand(i, V);
}
public:
/// isNullValue - Return true if this is the value that would be returned by
/// getNullValue.
@ -83,16 +87,13 @@ public:
/// FIXME: This really should not be in VMCore.
PossibleRelocationsTy getRelocationInfo() const;
// Specialize get/setOperand for Constants as their operands are always
// constants as well.
Constant *getOperand(unsigned i) {
return static_cast<Constant*>(User::getOperand(i));
// Specialize get/setOperand for Users as their operands are always
// constants or BasicBlocks as well.
User *getOperand(unsigned i) {
return static_cast<User*>(User::getOperand(i));
}
const Constant *getOperand(unsigned i) const {
return static_cast<const Constant*>(User::getOperand(i));
}
void setOperand(unsigned i, Constant *C) {
User::setOperand(i, C);
const User *getOperand(unsigned i) const {
return static_cast<const User*>(User::getOperand(i));
}
/// getVectorElements - This method, which is only valid on constant of vector

4
include/llvm/Constants.h
View File

@ -564,7 +564,7 @@ public:
static BlockAddress *get(BasicBlock *BB);
/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
Function *getFunction() const { return (Function*)Op<0>().get(); }
BasicBlock *getBasicBlock() const { return (BasicBlock*)Op<1>().get(); }
@ -587,7 +587,7 @@ template <>
struct OperandTraits<BlockAddress> : public FixedNumOperandTraits<2> {
};
DEFINE_TRANSPARENT_CASTED_OPERAND_ACCESSORS(BlockAddress, Constant)
DEFINE_TRANSPARENT_CASTED_OPERAND_ACCESSORS(BlockAddress, Value)
//===----------------------------------------------------------------------===//
/// ConstantExpr - a constant value that is initialized with an expression using

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

@ -751,10 +751,11 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal,
assert (0 && "Unknown FP type!");
}
} else if (isa<ConstantArray>(C) && cast<ConstantArray>(C)->isString()) {
const ConstantArray *CA = cast<ConstantArray>(C);
// Emit constant strings specially.
unsigned NumOps = C->getNumOperands();
unsigned NumOps = CA->getNumOperands();
// If this is a null-terminated string, use the denser CSTRING encoding.
if (C->getOperand(NumOps-1)->isNullValue()) {
if (CA->getOperand(NumOps-1)->isNullValue()) {
Code = bitc::CST_CODE_CSTRING;
--NumOps; // Don't encode the null, which isn't allowed by char6.
} else {
@ -764,7 +765,7 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal,
bool isCStr7 = Code == bitc::CST_CODE_CSTRING;
bool isCStrChar6 = Code == bitc::CST_CODE_CSTRING;
for (unsigned i = 0; i != NumOps; ++i) {
unsigned char V = cast<ConstantInt>(C->getOperand(i))->getZExtValue();
unsigned char V = cast<ConstantInt>(CA->getOperand(i))->getZExtValue();
Record.push_back(V);
isCStr7 &= (V & 128) == 0;
if (isCStrChar6)

2
lib/Target/MSIL/MSILWriter.cpp
View File

@ -1529,7 +1529,7 @@ void MSILWriter::printStaticConstant(const Constant* C, uint64_t& Offset) {
case Type::StructTyID:
for (unsigned I = 0, E = C->getNumOperands(); I<E; I++) {
if (I!=0) Out << ",\n";
printStaticConstant(C->getOperand(I),Offset);
printStaticConstant(cast<Constant>(C->getOperand(I)), Offset);
}
break;
case Type::PointerTyID:

9
lib/Transforms/IPO/StripSymbols.cpp
View File

@ -112,11 +112,11 @@ static bool OnlyUsedBy(Value *V, Value *Usr) {
static void RemoveDeadConstant(Constant *C) {
assert(C->use_empty() && "Constant is not dead!");
SmallPtrSet<Constant *, 4> Operands;
SmallPtrSet<Constant*, 4> Operands;
for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i)
if (isa<DerivedType>(C->getOperand(i)->getType()) &&
OnlyUsedBy(C->getOperand(i), C))
Operands.insert(C->getOperand(i));
Operands.insert(cast<Constant>(C->getOperand(i)));
if (GlobalVariable *GV = dyn_cast<GlobalVariable>(C)) {
if (!GV->hasLocalLinkage()) return; // Don't delete non static globals.
GV->eraseFromParent();
@ -126,7 +126,7 @@ static void RemoveDeadConstant(Constant *C) {
C->destroyConstant();
// If the constant referenced anything, see if we can delete it as well.
for (SmallPtrSet<Constant *, 4>::iterator OI = Operands.begin(),
for (SmallPtrSet<Constant*, 4>::iterator OI = Operands.begin(),
OE = Operands.end(); OI != OE; ++OI)
RemoveDeadConstant(*OI);
}
@ -305,8 +305,7 @@ bool StripDebugDeclare::runOnModule(Module &M) {
if (GlobalVariable *GV = dyn_cast<GlobalVariable>(C)) {
if (GV->hasLocalLinkage())
RemoveDeadConstant(GV);
}
else
} else
RemoveDeadConstant(C);
}

39
lib/VMCore/ConstantFold.cpp
View File

@ -215,7 +215,7 @@ static Constant *ExtractConstantBytes(Constant *C, unsigned ByteStart,
switch (CE->getOpcode()) {
default: return 0;
case Instruction::Or: {
Constant *RHS = ExtractConstantBytes(C->getOperand(1), ByteStart, ByteSize);
Constant *RHS = ExtractConstantBytes(CE->getOperand(1), ByteStart,ByteSize);
if (RHS == 0)
return 0;
@ -224,13 +224,13 @@ static Constant *ExtractConstantBytes(Constant *C, unsigned ByteStart,
if (RHSC->isAllOnesValue())
return RHSC;
Constant *LHS = ExtractConstantBytes(C->getOperand(0), ByteStart, ByteSize);
Constant *LHS = ExtractConstantBytes(CE->getOperand(0), ByteStart,ByteSize);
if (LHS == 0)
return 0;
return ConstantExpr::getOr(LHS, RHS);
}
case Instruction::And: {
Constant *RHS = ExtractConstantBytes(C->getOperand(1), ByteStart, ByteSize);
Constant *RHS = ExtractConstantBytes(CE->getOperand(1), ByteStart,ByteSize);
if (RHS == 0)
return 0;
@ -238,7 +238,7 @@ static Constant *ExtractConstantBytes(Constant *C, unsigned ByteStart,
if (RHS->isNullValue())
return RHS;
Constant *LHS = ExtractConstantBytes(C->getOperand(0), ByteStart, ByteSize);
Constant *LHS = ExtractConstantBytes(CE->getOperand(0), ByteStart,ByteSize);
if (LHS == 0)
return 0;
return ConstantExpr::getAnd(LHS, RHS);
@ -259,7 +259,7 @@ static Constant *ExtractConstantBytes(Constant *C, unsigned ByteStart,
ByteSize*8));
// If the extract is known to be fully in the input, extract it.
if (ByteStart+ByteSize+ShAmt <= CSize)
return ExtractConstantBytes(C->getOperand(0), ByteStart+ShAmt, ByteSize);
return ExtractConstantBytes(CE->getOperand(0), ByteStart+ShAmt, ByteSize);
// TODO: Handle the 'partially zero' case.
return 0;
@ -281,7 +281,7 @@ static Constant *ExtractConstantBytes(Constant *C, unsigned ByteStart,
ByteSize*8));
// If the extract is known to be fully in the input, extract it.
if (ByteStart >= ShAmt)
return ExtractConstantBytes(C->getOperand(0), ByteStart-ShAmt, ByteSize);
return ExtractConstantBytes(CE->getOperand(0), ByteStart-ShAmt, ByteSize);
// TODO: Handle the 'partially zero' case.
return 0;
@ -289,7 +289,7 @@ static Constant *ExtractConstantBytes(Constant *C, unsigned ByteStart,
case Instruction::ZExt: {
unsigned SrcBitSize =
cast<IntegerType>(C->getOperand(0)->getType())->getBitWidth();
cast<IntegerType>(CE->getOperand(0)->getType())->getBitWidth();
// If extracting something that is completely zero, return 0.
if (ByteStart*8 >= SrcBitSize)
@ -298,18 +298,18 @@ static Constant *ExtractConstantBytes(Constant *C, unsigned ByteStart,
// If exactly extracting the input, return it.
if (ByteStart == 0 && ByteSize*8 == SrcBitSize)
return C->getOperand(0);
return CE->getOperand(0);
// If extracting something completely in the input, if if the input is a
// multiple of 8 bits, recurse.
if ((SrcBitSize&7) == 0 && (ByteStart+ByteSize)*8 <= SrcBitSize)
return ExtractConstantBytes(C->getOperand(0), ByteStart, ByteSize);
return ExtractConstantBytes(CE->getOperand(0), ByteStart, ByteSize);
// Otherwise, if extracting a subset of the input, which is not multiple of
// 8 bits, do a shift and trunc to get the bits.
if ((ByteStart+ByteSize)*8 < SrcBitSize) {
assert((SrcBitSize&7) && "Shouldn't get byte sized case here");
Constant *Res = C->getOperand(0);
Constant *Res = CE->getOperand(0);
if (ByteStart)
Res = ConstantExpr::getLShr(Res,
ConstantInt::get(Res->getType(), ByteStart*8));
@ -634,7 +634,15 @@ Constant *llvm::ConstantFoldExtractValueInstruction(LLVMContext &Context,
Idxs + NumIdx));
// Otherwise recurse.
return ConstantFoldExtractValueInstruction(Context, Agg->getOperand(*Idxs),
if (ConstantStruct *CS = dyn_cast<ConstantStruct>(Agg))
return ConstantFoldExtractValueInstruction(Context, CS->getOperand(*Idxs),
Idxs+1, NumIdx-1);
if (ConstantArray *CA = dyn_cast<ConstantArray>(Agg))
return ConstantFoldExtractValueInstruction(Context, CA->getOperand(*Idxs),
Idxs+1, NumIdx-1);
ConstantVector *CV = cast<ConstantVector>(Agg);
return ConstantFoldExtractValueInstruction(Context, CV->getOperand(*Idxs),
Idxs+1, NumIdx-1);
}
@ -714,11 +722,10 @@ Constant *llvm::ConstantFoldInsertValueInstruction(LLVMContext &Context,
// Insertion of constant into aggregate constant.
std::vector<Constant*> Ops(Agg->getNumOperands());
for (unsigned i = 0; i < Agg->getNumOperands(); ++i) {
Constant *Op =
(*Idxs == i) ?
ConstantFoldInsertValueInstruction(Context, Agg->getOperand(i),
Val, Idxs+1, NumIdx-1) :
Agg->getOperand(i);
Constant *Op = cast<Constant>(Agg->getOperand(i));
if (*Idxs == i)
Op = ConstantFoldInsertValueInstruction(Context, Op,
Val, Idxs+1, NumIdx-1);
Ops[i] = Op;
}

7
lib/VMCore/Constants.cpp
View File

@ -140,7 +140,7 @@ bool Constant::canTrap() const {
// ConstantExpr traps if any operands can trap.
for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
if (getOperand(i)->canTrap())
if (CE->getOperand(i)->canTrap())
return true;
// Otherwise, only specific operations can trap.
@ -154,7 +154,7 @@ bool Constant::canTrap() const {
case Instruction::SRem:
case Instruction::FRem:
// Div and rem can trap if the RHS is not known to be non-zero.
if (!isa<ConstantInt>(getOperand(1)) || getOperand(1)->isNullValue())
if (!isa<ConstantInt>(CE->getOperand(1)) ||CE->getOperand(1)->isNullValue())
return true;
return false;
}
@ -187,7 +187,8 @@ Constant::PossibleRelocationsTy Constant::getRelocationInfo() const {
PossibleRelocationsTy Result = NoRelocation;
for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
Result = std::max(Result, getOperand(i)->getRelocationInfo());
Result = std::max(Result,
cast<Constant>(getOperand(i))->getRelocationInfo());
return Result;
}