RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2025-02-22 13:32:09 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Adjustments to support the new ConstantAggregateZero class

Browse Source 
llvm-svn: 11474
This commit is contained in:
Chris Lattner 2004-02-15 05:55:15 +00:00
parent 99ed412516
commit 28131460da
7 changed files with 37 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
lib/Target/Sparc/EmitAssembly.cpp
View File

@ -387,8 +387,9 @@ void AsmPrinter::printConstantValueOnly(const Constant* CV,
}
assert(sizeSoFar == cvsLayout->StructSize &&
"Layout of constant struct may be incorrect!");
}
else
} else if (isa<ConstantAggregateZero>(CV)) {
PrintZeroBytesToPad(Target.getTargetData().getTypeSize(CV->getType()));
} else
printSingleConstantValue(CV);
if (numPadBytesAfter)

6
lib/Transforms/Scalar/InstructionCombining.cpp
View File

@ -2088,11 +2088,13 @@ static Constant *GetGEPGlobalInitializer(Constant *C, ConstantExpr *CE) {
// addressing...
for (unsigned i = 2, e = CE->getNumOperands(); i != e; ++i)
if (ConstantUInt *CU = dyn_cast<ConstantUInt>(CE->getOperand(i))) {
ConstantStruct *CS = cast<ConstantStruct>(C);
ConstantStruct *CS = dyn_cast<ConstantStruct>(C);
if (CS == 0) return 0;
if (CU->getValue() >= CS->getValues().size()) return 0;
C = cast<Constant>(CS->getValues()[CU->getValue()]);
} else if (ConstantSInt *CS = dyn_cast<ConstantSInt>(CE->getOperand(i))) {
ConstantArray *CA = cast<ConstantArray>(C);
ConstantArray *CA = dyn_cast<ConstantArray>(C);
if (CA == 0) return 0;
if ((uint64_t)CS->getValue() >= CA->getValues().size()) return 0;
C = cast<Constant>(CA->getValues()[CS->getValue()]);
} else

8
lib/Transforms/Scalar/SCCP.cpp
View File

@ -689,14 +689,16 @@ static Constant *GetGEPGlobalInitializer(Constant *C, ConstantExpr *CE) {
// addressing...
for (unsigned i = 2, e = CE->getNumOperands(); i != e; ++i)
if (ConstantUInt *CU = dyn_cast<ConstantUInt>(CE->getOperand(i))) {
ConstantStruct *CS = cast<ConstantStruct>(C);
ConstantStruct *CS = dyn_cast<ConstantStruct>(C);
if (CS == 0) return 0;
if (CU->getValue() >= CS->getValues().size()) return 0;
C = cast<Constant>(CS->getValues()[CU->getValue()]);
} else if (ConstantSInt *CS = dyn_cast<ConstantSInt>(CE->getOperand(i))) {
ConstantArray *CA = cast<ConstantArray>(C);
ConstantArray *CA = dyn_cast<ConstantArray>(C);
if (CA == 0) return 0;
if ((uint64_t)CS->getValue() >= CA->getValues().size()) return 0;
C = cast<Constant>(CA->getValues()[CS->getValue()]);
} else
} else
return 0;
return C;
}

27
lib/Transforms/Utils/Linker.cpp
View File

@ -284,7 +284,8 @@ static Value *RemapOperand(const Value *In,
// Check to see if it's a constant that we are interesting in transforming...
if (const Constant *CPV = dyn_cast<Constant>(In)) {
if (!isa<DerivedType>(CPV->getType()) && !isa<ConstantExpr>(CPV))
if ((!isa<DerivedType>(CPV->getType()) && !isa<ConstantExpr>(CPV)) ||
isa<ConstantAggregateZero>(CPV))
return const_cast<Constant*>(CPV); // Simple constants stay identical...
Constant *Result = 0;
@ -796,12 +797,24 @@ static bool LinkAppendingVars(Module *M,
// Merge the initializer...
Inits.reserve(NewSize);
ConstantArray *I = cast<ConstantArray>(G1->getInitializer());
for (unsigned i = 0, e = T1->getNumElements(); i != e; ++i)
Inits.push_back(cast<Constant>(I->getValues()[i]));
I = cast<ConstantArray>(G2->getInitializer());
for (unsigned i = 0, e = T2->getNumElements(); i != e; ++i)
Inits.push_back(cast<Constant>(I->getValues()[i]));
if (ConstantArray *I = dyn_cast<ConstantArray>(G1->getInitializer())) {
for (unsigned i = 0, e = T1->getNumElements(); i != e; ++i)
Inits.push_back(cast<Constant>(I->getValues()[i]));
} else {
assert(isa<ConstantAggregateZero>(G1->getInitializer()));
Constant *CV = Constant::getNullValue(T1->getElementType());
for (unsigned i = 0, e = T1->getNumElements(); i != e; ++i)
Inits.push_back(CV);
}
if (ConstantArray *I = dyn_cast<ConstantArray>(G2->getInitializer())) {
for (unsigned i = 0, e = T2->getNumElements(); i != e; ++i)
Inits.push_back(cast<Constant>(I->getValues()[i]));
} else {
assert(isa<ConstantAggregateZero>(G2->getInitializer()));
Constant *CV = Constant::getNullValue(T2->getElementType());
for (unsigned i = 0, e = T2->getNumElements(); i != e; ++i)
Inits.push_back(CV);
}
NG->setInitializer(ConstantArray::get(NewType, Inits));
Inits.clear();

2
lib/Transforms/Utils/ValueMapper.cpp
View File

@ -28,7 +28,7 @@ Value *llvm::MapValue(const Value *V, std::map<const Value*, Value*> &VM) {
if (Constant *C = const_cast<Constant*>(dyn_cast<Constant>(V))) {
if (isa<ConstantIntegral>(C) || isa<ConstantFP>(C) ||
isa<ConstantPointerNull>(C))
isa<ConstantPointerNull>(C) || isa<ConstantAggregateZero>(C))
return VMSlot = C; // Primitive constants map directly
else if (ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(C)) {
GlobalValue *MV = cast<GlobalValue>(MapValue((Value*)CPR->getValue(),VM));

12
lib/VMCore/AsmWriter.cpp
View File

@ -288,12 +288,9 @@ static void WriteConstantInt(std::ostream &Out, const Constant *CV,
"assuming that double is 64 bits!");
Out << "0x" << utohexstr(*(uint64_t*)Ptr);
} else if (isa<ConstantAggregateZero>(CV)) {
Out << "zeroinitializer";
} else if (const ConstantArray *CA = dyn_cast<ConstantArray>(CV)) {
if (CA->getNumOperands() > 5 && CA->isNullValue()) {
Out << "zeroinitializer";
return;
}
// As a special case, print the array as a string if it is an array of
// ubytes or an array of sbytes with positive values.
//
@ -339,11 +336,6 @@ static void WriteConstantInt(std::ostream &Out, const Constant *CV,
Out << " ]";
}
} else if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(CV)) {
if (CS->getNumOperands() > 5 && CS->isNullValue()) {
Out << "zeroinitializer";
return;
}
Out << "{";
if (CS->getNumOperands()) {
Out << " ";

3
lib/VMCore/SlotCalculator.cpp
View File

@ -146,7 +146,8 @@ void SlotCalculator::processModule() {
TypePlane &Plane = Table[plane];
unsigned FirstNonStringID = 0;
for (unsigned i = 0, e = Plane.size(); i != e; ++i)
if (cast<ConstantArray>(Plane[i])->isString()) {
if (isa<ConstantAggregateZero>(Plane[i]) ||
cast<ConstantArray>(Plane[i])->isString()) {
// Check to see if we have to shuffle this string around. If not,
// don't do anything.
if (i != FirstNonStringID) {