From d23c4dd08fc887bf69fc81eaed4d440403451c58 Mon Sep 17 00:00:00 2001 From: Reid Spencer Date: Mon, 16 Apr 2007 00:39:39 +0000 Subject: [PATCH] For PR1336: Rewrite the upgrade of GEP indices to be a little less obtuse. This fixes test/Assembler/2002-08-19-BytecodeReader.llx test/Assembler/2003-08-21-ConstantExprCast-Fold.llx test/Assembler/2004-01-11-getelementptrfolding.llx git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36095 91177308-0d34-0410-b5e6-96231b3b80d8 --- tools/llvm-upgrade/UpgradeParser.y | 105 ++++++++++++++++++----------- 1 file changed, 66 insertions(+), 39 deletions(-) diff --git a/tools/llvm-upgrade/UpgradeParser.y b/tools/llvm-upgrade/UpgradeParser.y index 0173b44dddc..697c7af2f88 100644 --- a/tools/llvm-upgrade/UpgradeParser.y +++ b/tools/llvm-upgrade/UpgradeParser.y @@ -1529,56 +1529,84 @@ upgradeIntrinsicCall(const Type* RetTy, const ValID &ID, return 0; } -const Type* upgradeGEPIndices(const Type* PTy, - std::vector *Indices, - std::vector &VIndices, - std::vector *CIndices = 0) { - // Traverse the indices with a gep_type_iterator so we can build the list - // of constant and value indices for use later. Also perform upgrades - VIndices.clear(); - if (CIndices) CIndices->clear(); - for (unsigned i = 0, e = Indices->size(); i != e; ++i) - VIndices.push_back((*Indices)[i].V); - generic_gep_type_iterator::iterator> - GTI = gep_type_begin(PTy, VIndices.begin(), VIndices.end()), - GTE = gep_type_end(PTy, VIndices.begin(), VIndices.end()); - for (unsigned i = 0, e = Indices->size(); i != e && GTI != GTE; ++i, ++GTI) { - Value *Index = VIndices[i]; - if (CIndices && !isa(Index)) - error("Indices to constant getelementptr must be constants"); - // LLVM 1.2 and earlier used ubyte struct indices. Convert any ubyte - // struct indices to i32 struct indices with ZExt for compatibility. - else if (isa(*GTI)) { // Only change struct indices - if (ConstantInt *CUI = dyn_cast(Index)) - if (CUI->getType()->getBitWidth() == 8) - Index = - ConstantExpr::getCast(Instruction::ZExt, CUI, Type::Int32Ty); +const Type* upgradeGEPCEIndices(const Type* PTy, + std::vector *Indices, + std::vector &Result) { + const Type *Ty = PTy; + Result.clear(); + for (unsigned i = 0, e = Indices->size(); i != e ; ++i) { + Constant *Index = cast((*Indices)[i].V); + + if (ConstantInt *CI = dyn_cast(Index)) { + // LLVM 1.2 and earlier used ubyte struct indices. Convert any ubyte + // struct indices to i32 struct indices with ZExt for compatibility. + if (CI->getBitWidth() < 32) + Index = ConstantExpr::getCast(Instruction::ZExt, CI, Type::Int32Ty); + } + + if (isa(Ty)) { + // Make sure that unsigned SequentialType indices are zext'd to + // 64-bits if they were smaller than that because LLVM 2.0 will sext + // all indices for SequentialType elements. We must retain the same + // semantic (zext) for unsigned types. + if (const IntegerType *Ity = dyn_cast(Index->getType())) { + if (Ity->getBitWidth() < 64 && (*Indices)[i].S.isUnsigned()) { + Index = ConstantExpr::getCast(Instruction::ZExt, Index,Type::Int64Ty); + } + } + } + Result.push_back(Index); + Ty = GetElementPtrInst::getIndexedType(PTy, (Value**)&Result[0], + Result.size(),true); + if (!Ty) + error("Index list invalid for constant getelementptr"); + } + return Ty; +} + +const Type* upgradeGEPInstIndices(const Type* PTy, + std::vector *Indices, + std::vector &Result) { + const Type *Ty = PTy; + Result.clear(); + for (unsigned i = 0, e = Indices->size(); i != e ; ++i) { + Value *Index = (*Indices)[i].V; + + if (ConstantInt *CI = dyn_cast(Index)) { + // LLVM 1.2 and earlier used ubyte struct indices. Convert any ubyte + // struct indices to i32 struct indices with ZExt for compatibility. + if (CI->getBitWidth() < 32) + Index = ConstantExpr::getCast(Instruction::ZExt, CI, Type::Int32Ty); + } + + + if (isa(Ty)) { // Only change struct indices + if (!isa(Index)) { + error("Invalid non-constant structure index"); + return 0; + } } else { // Make sure that unsigned SequentialType indices are zext'd to // 64-bits if they were smaller than that because LLVM 2.0 will sext // all indices for SequentialType elements. We must retain the same // semantic (zext) for unsigned types. - if (const IntegerType *Ity = dyn_cast(Index->getType())) + if (const IntegerType *Ity = dyn_cast(Index->getType())) { if (Ity->getBitWidth() < 64 && (*Indices)[i].S.isUnsigned()) { - if (CIndices) + if (isa(Index)) Index = ConstantExpr::getCast(Instruction::ZExt, cast(Index), Type::Int64Ty); else Index = CastInst::create(Instruction::ZExt, Index, Type::Int64Ty, makeNameUnique("gep"), CurBB); - VIndices[i] = Index; } + } } - // Add to the CIndices list, if requested. - if (CIndices) - CIndices->push_back(cast(Index)); - } - - const Type *IdxTy = - GetElementPtrInst::getIndexedType(PTy, &VIndices[0], VIndices.size(), true); - if (!IdxTy) + Result.push_back(Index); + Ty = GetElementPtrInst::getIndexedType(PTy, &Result[0], Result.size(),true); + if (!Ty) error("Index list invalid for constant getelementptr"); - return IdxTy; + } + return Ty; } unsigned upgradeCallingConv(unsigned CC) { @@ -2525,9 +2553,8 @@ ConstExpr if (!isa(Ty)) error("GetElementPtr requires a pointer operand"); - std::vector VIndices; std::vector CIndices; - upgradeGEPIndices($3.C->getType(), $4, VIndices, &CIndices); + upgradeGEPCEIndices($3.C->getType(), $4, CIndices); delete $4; $$.C = ConstantExpr::getGetElementPtr($3.C, &CIndices[0], CIndices.size()); @@ -3857,7 +3884,7 @@ MemoryInst error("getelementptr insn requires pointer operand"); std::vector VIndices; - upgradeGEPIndices(Ty, $4, VIndices); + upgradeGEPInstIndices(Ty, $4, VIndices); Value* tmpVal = getVal(Ty, $3); $$.I = new GetElementPtrInst(tmpVal, &VIndices[0], VIndices.size());