diff options
author | Chris Lattner <sabre@nondot.org> | 2004-04-05 01:30:19 +0000 |
---|---|---|
committer | Chris Lattner <sabre@nondot.org> | 2004-04-05 01:30:19 +0000 |
commit | 28977af72a11fcad5d1b54d7a96b3df02828f6fc (patch) | |
tree | 671a8fa4df839cb653ebd22dda8fa39639b3afa7 /lib/Transforms | |
parent | 830b6f98686f40f86811dceb5497433ebac385e1 (diff) | |
download | external_llvm-28977af72a11fcad5d1b54d7a96b3df02828f6fc.zip external_llvm-28977af72a11fcad5d1b54d7a96b3df02828f6fc.tar.gz external_llvm-28977af72a11fcad5d1b54d7a96b3df02828f6fc.tar.bz2 |
Support getelementptr instructions which use uint's to index into structure
types and can have arbitrary 32- and 64-bit integer types indexing into
sequential types.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@12653 91177308-0d34-0410-b5e6-96231b3b80d8
Diffstat (limited to 'lib/Transforms')
-rw-r--r-- | lib/Transforms/ExprTypeConvert.cpp | 31 | ||||
-rw-r--r-- | lib/Transforms/Instrumentation/ProfilingUtils.cpp | 6 | ||||
-rw-r--r-- | lib/Transforms/LevelRaise.cpp | 7 | ||||
-rw-r--r-- | lib/Transforms/Scalar/InstructionCombining.cpp | 133 | ||||
-rw-r--r-- | lib/Transforms/Scalar/SCCP.cpp | 2 | ||||
-rw-r--r-- | lib/Transforms/Scalar/ScalarReplAggregates.cpp | 2 | ||||
-rw-r--r-- | lib/Transforms/TransformInternals.cpp | 110 | ||||
-rw-r--r-- | lib/Transforms/Utils/LowerInvoke.cpp | 10 |
8 files changed, 145 insertions, 156 deletions
diff --git a/lib/Transforms/ExprTypeConvert.cpp b/lib/Transforms/ExprTypeConvert.cpp index b30ddf1..bde24f0 100644 --- a/lib/Transforms/ExprTypeConvert.cpp +++ b/lib/Transforms/ExprTypeConvert.cpp @@ -797,10 +797,13 @@ static bool OperandConvertibleToType(User *U, Value *V, const Type *Ty, // stream, so we have to delete it when we're done. // if (DataSize != 1) { - // FIXME, PR82 - TempScale = BinaryOperator::create(Instruction::Mul, Index, - ConstantSInt::get(Type::LongTy, - DataSize)); + Value *CST; + if (Index->getType()->isSigned()) + CST = ConstantSInt::get(Index->getType(), DataSize); + else + CST = ConstantUInt::get(Index->getType(), DataSize); + + TempScale = BinaryOperator::create(Instruction::Mul, Index, CST); Index = TempScale; } @@ -1012,8 +1015,7 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, if (const CompositeType *CT = dyn_cast<CompositeType>(LoadedTy)) { std::vector<Value*> Indices; - // FIXME, PR82 - Indices.push_back(ConstantSInt::get(Type::LongTy, 0)); + Indices.push_back(Constant::getNullValue(Type::UIntTy)); unsigned Offset = 0; // No offset, get first leaf. LoadedTy = getStructOffsetType(CT, Offset, Indices, TD, false); @@ -1049,8 +1051,7 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, const StructType *SElTy = cast<StructType>(ElTy); std::vector<Value*> Indices; - // FIXME, PR82 - Indices.push_back(Constant::getNullValue(Type::LongTy)); + Indices.push_back(Constant::getNullValue(Type::UIntTy)); unsigned Offset = 0; const Type *Ty = getStructOffsetType(ElTy, Offset, Indices, TD,false); @@ -1079,8 +1080,7 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, if (isa<StructType>(ValTy)) { std::vector<Value*> Indices; - // FIXME: PR82 - Indices.push_back(Constant::getNullValue(Type::LongTy)); + Indices.push_back(Constant::getNullValue(Type::UIntTy)); unsigned Offset = 0; ValTy = getStructOffsetType(ValTy, Offset, Indices, TD, false); @@ -1112,10 +1112,13 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, if (DataSize != 1) { // Insert a multiply of the old element type is not a unit size... - Index = BinaryOperator::create(Instruction::Mul, Index, - // FIXME: PR82 - ConstantSInt::get(Type::LongTy, DataSize), - "scale", It); + Value *CST; + if (Index->getType()->isSigned()) + CST = ConstantSInt::get(Index->getType(), DataSize); + else + CST = ConstantUInt::get(Index->getType(), DataSize); + + Index = BinaryOperator::create(Instruction::Mul, Index, CST, "scale", It); } // Perform the conversion now... diff --git a/lib/Transforms/Instrumentation/ProfilingUtils.cpp b/lib/Transforms/Instrumentation/ProfilingUtils.cpp index 5baefe9..4cdcb9e 100644 --- a/lib/Transforms/Instrumentation/ProfilingUtils.cpp +++ b/lib/Transforms/Instrumentation/ProfilingUtils.cpp @@ -40,7 +40,7 @@ void llvm::InsertProfilingInitCall(Function *MainFn, const char *FnName, while (isa<AllocaInst>(InsertPos)) ++InsertPos; ConstantPointerRef *ArrayCPR = ConstantPointerRef::get(Array); - std::vector<Constant*> GEPIndices(2, Constant::getNullValue(Type::LongTy)); + std::vector<Constant*> GEPIndices(2, Constant::getNullValue(Type::IntTy)); Args[2] = ConstantExpr::getGetElementPtr(ArrayCPR, GEPIndices); unsigned NumElements = @@ -89,8 +89,8 @@ void llvm::IncrementCounterInBlock(BasicBlock *BB, unsigned CounterNum, // Create the getelementptr constant expression std::vector<Constant*> Indices(2); - Indices[0] = Constant::getNullValue(Type::LongTy); - Indices[1] = ConstantSInt::get(Type::LongTy, CounterNum); + Indices[0] = Constant::getNullValue(Type::IntTy); + Indices[1] = ConstantSInt::get(Type::IntTy, CounterNum); Constant *ElementPtr = ConstantExpr::getGetElementPtr(CounterArray, Indices); // Load, increment and store the value back. diff --git a/lib/Transforms/LevelRaise.cpp b/lib/Transforms/LevelRaise.cpp index edc42b7..aeb836d 100644 --- a/lib/Transforms/LevelRaise.cpp +++ b/lib/Transforms/LevelRaise.cpp @@ -370,9 +370,8 @@ bool RPR::PeepholeOptimize(BasicBlock *BB, BasicBlock::iterator &BI) { // Build the index vector, full of all zeros std::vector<Value*> Indices; - Indices.push_back(ConstantSInt::get(Type::LongTy, 0)); // FIXME, PR82 + Indices.push_back(Constant::getNullValue(Type::UIntTy)); while (CurCTy && !isa<PointerType>(CurCTy)) { - const Type *IdxType; if (const StructType *CurSTy = dyn_cast<StructType>(CurCTy)) { // Check for a zero element struct type... if we have one, bail. if (CurSTy->getNumElements() == 0) break; @@ -381,14 +380,12 @@ bool RPR::PeepholeOptimize(BasicBlock *BB, BasicBlock::iterator &BI) { // offset zero in the struct. // ElTy = CurSTy->getElementType(0); - IdxType = Type::UByteTy; // FIXME when PR82 is fixed. } else { ElTy = cast<ArrayType>(CurCTy)->getElementType(); - IdxType = Type::LongTy; // FIXME when PR82 is fixed. } // Insert a zero to index through this type... - Indices.push_back(Constant::getNullValue(IdxType)); + Indices.push_back(Constant::getNullValue(Type::UIntTy)); // Did we find what we're looking for? if (ElTy->isLosslesslyConvertibleTo(DestPointedTy)) break; diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp index 13c6b26..a1e6c99 100644 --- a/lib/Transforms/Scalar/InstructionCombining.cpp +++ b/lib/Transforms/Scalar/InstructionCombining.cpp @@ -44,9 +44,10 @@ #include "llvm/Target/TargetData.h" #include "llvm/Transforms/Utils/BasicBlockUtils.h" #include "llvm/Transforms/Utils/Local.h" +#include "llvm/Support/CallSite.h" +#include "llvm/Support/GetElementPtrTypeIterator.h" #include "llvm/Support/InstIterator.h" #include "llvm/Support/InstVisitor.h" -#include "llvm/Support/CallSite.h" #include "Support/Debug.h" #include "Support/Statistic.h" #include <algorithm> @@ -92,6 +93,8 @@ namespace { AU.setPreservesCFG(); } + TargetData &getTargetData() const { return *TD; } + // Visitation implementation - Implement instruction combining for different // instruction types. The semantics are as follows: // Return Value: @@ -127,6 +130,7 @@ namespace { Instruction *visitCallSite(CallSite CS); bool transformConstExprCastCall(CallSite CS); + public: // InsertNewInstBefore - insert an instruction New before instruction Old // in the program. Add the new instruction to the worklist. // @@ -139,7 +143,6 @@ namespace { return New; } - public: // ReplaceInstUsesWith - This method is to be used when an instruction is // found to be dead, replacable with another preexisting expression. Here // we add all uses of I to the worklist, replace all uses of I with the new @@ -2272,6 +2275,20 @@ Instruction *InstCombiner::visitPHINode(PHINode &PN) { return 0; } +static Value *InsertSignExtendToPtrTy(Value *V, const Type *DTy, + Instruction *InsertPoint, + InstCombiner *IC) { + unsigned PS = IC->getTargetData().getPointerSize(); + const Type *VTy = V->getType(); + Instruction *Cast; + if (!VTy->isSigned() && VTy->getPrimitiveSize() < PS) + // We must insert a cast to ensure we sign-extend. + V = IC->InsertNewInstBefore(new CastInst(V, VTy->getSignedVersion(), + V->getName()), *InsertPoint); + return IC->InsertNewInstBefore(new CastInst(V, DTy, V->getName()), + *InsertPoint); +} + Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) { // Is it 'getelementptr %P, long 0' or 'getelementptr %P' @@ -2286,6 +2303,37 @@ Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) { if (GEP.getNumOperands() == 2 && HasZeroPointerIndex) return ReplaceInstUsesWith(GEP, GEP.getOperand(0)); + // Eliminate unneeded casts for indices. + bool MadeChange = false; + for (unsigned i = 1, e = GEP.getNumOperands(); i != e; ++i) + if (CastInst *CI = dyn_cast<CastInst>(GEP.getOperand(i))) { + Value *Src = CI->getOperand(0); + const Type *SrcTy = Src->getType(); + const Type *DestTy = CI->getType(); + if (Src->getType()->isInteger()) { + if (SrcTy->getPrimitiveSize() == DestTy->getPrimitiveSize()) { + // We can always eliminate a cast from ulong or long to the other. We + // can always eliminate a cast from uint to int or the other on 32-bit + // pointer platforms. + if (DestTy->getPrimitiveSize() >= TD->getPointerSize()) { + MadeChange = true; + GEP.setOperand(i, Src); + } + } else if (SrcTy->getPrimitiveSize() < DestTy->getPrimitiveSize() && + SrcTy->getPrimitiveSize() == 4) { + // We can always eliminate a cast from int to [u]long. We can + // eliminate a cast from uint to [u]long iff the target is a 32-bit + // pointer target. + if (SrcTy->isSigned() || + SrcTy->getPrimitiveSize() >= TD->getPointerSize()) { + MadeChange = true; + GEP.setOperand(i, Src); + } + } + } + } + if (MadeChange) return &GEP; + // Combine Indices - If the source pointer to this getelementptr instruction // is a getelementptr instruction, combine the indices of the two // getelementptr instructions into a single instruction. @@ -2304,14 +2352,17 @@ Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) { // Can we combine the two pointer arithmetics offsets? if (SrcGEPOperands.size() == 2 && isa<Constant>(SrcGEPOperands[1]) && isa<Constant>(GEP.getOperand(1))) { + Constant *SGC = cast<Constant>(SrcGEPOperands[1]); + Constant *GC = cast<Constant>(GEP.getOperand(1)); + if (SGC->getType() != GC->getType()) { + SGC = ConstantExpr::getSignExtend(SGC, Type::LongTy); + GC = ConstantExpr::getSignExtend(GC, Type::LongTy); + } + // Replace: gep (gep %P, long C1), long C2, ... // With: gep %P, long (C1+C2), ... - Value *Sum = ConstantExpr::get(Instruction::Add, - cast<Constant>(SrcGEPOperands[1]), - cast<Constant>(GEP.getOperand(1))); - assert(Sum && "Constant folding of longs failed!?"); GEP.setOperand(0, SrcGEPOperands[0]); - GEP.setOperand(1, Sum); + GEP.setOperand(1, ConstantExpr::getAdd(SGC, GC)); if (Instruction *I = dyn_cast<Instruction>(GEP.getOperand(0))) AddUsersToWorkList(*I); // Reduce use count of Src return &GEP; @@ -2327,29 +2378,65 @@ Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) { cast<Instruction>(SrcGEPOperands[0])->getNumOperands() == 2) return 0; // Wait until our source is folded to completion. - Value *Sum = BinaryOperator::create(Instruction::Add, SrcGEPOperands[1], - GEP.getOperand(1), - GEP.getOperand(0)->getName()+".sum", - &GEP); + Value *Sum, *SO1 = SrcGEPOperands[1], *GO1 = GEP.getOperand(1); + if (SO1 == Constant::getNullValue(SO1->getType())) { + Sum = GO1; + } else if (GO1 == Constant::getNullValue(GO1->getType())) { + Sum = SO1; + } else { + // If they aren't the same type, convert both to an integer of the + // target's pointer size. + if (SO1->getType() != GO1->getType()) { + if (Constant *SO1C = dyn_cast<Constant>(SO1)) { + SO1 = ConstantExpr::getCast(SO1C, GO1->getType()); + } else if (Constant *GO1C = dyn_cast<Constant>(GO1)) { + GO1 = ConstantExpr::getCast(GO1C, SO1->getType()); + } else { + unsigned PS = TD->getPointerSize(); + Instruction *Cast; + if (SO1->getType()->getPrimitiveSize() == PS) { + // Convert GO1 to SO1's type. + GO1 = InsertSignExtendToPtrTy(GO1, SO1->getType(), &GEP, this); + + } else if (GO1->getType()->getPrimitiveSize() == PS) { + // Convert SO1 to GO1's type. + SO1 = InsertSignExtendToPtrTy(SO1, GO1->getType(), &GEP, this); + } else { + const Type *PT = TD->getIntPtrType(); + SO1 = InsertSignExtendToPtrTy(SO1, PT, &GEP, this); + GO1 = InsertSignExtendToPtrTy(GO1, PT, &GEP, this); + } + } + } + Sum = BinaryOperator::create(Instruction::Add, SO1, GO1, + GEP.getOperand(0)->getName()+".sum", &GEP); + } GEP.setOperand(0, SrcGEPOperands[0]); GEP.setOperand(1, Sum); WorkList.push_back(cast<Instruction>(Sum)); return &GEP; - } else if (*GEP.idx_begin() == Constant::getNullValue(Type::LongTy) && + } else if (isa<Constant>(*GEP.idx_begin()) && + cast<Constant>(*GEP.idx_begin())->isNullValue() && SrcGEPOperands.size() != 1) { // Otherwise we can do the fold if the first index of the GEP is a zero Indices.insert(Indices.end(), SrcGEPOperands.begin()+1, SrcGEPOperands.end()); Indices.insert(Indices.end(), GEP.idx_begin()+1, GEP.idx_end()); - } else if (SrcGEPOperands.back() == Constant::getNullValue(Type::LongTy)) { - // FIXME: when we allow indices to be non-long values, support this for - // other types! - - // If the src gep ends with a constant array index, merge this get into - // it, even if we have a non-zero array index. - Indices.insert(Indices.end(), SrcGEPOperands.begin()+1, - SrcGEPOperands.end()-1); - Indices.insert(Indices.end(), GEP.idx_begin(), GEP.idx_end()); + } else if (SrcGEPOperands.back() == + Constant::getNullValue(SrcGEPOperands.back()->getType())) { + // We have to check to make sure this really is an ARRAY index we are + // ending up with, not a struct index. + generic_gep_type_iterator<std::vector<Value*>::iterator> + GTI = gep_type_begin(SrcGEPOperands[0]->getType(), + SrcGEPOperands.begin()+1, SrcGEPOperands.end()); + std::advance(GTI, SrcGEPOperands.size()-2); + if (isa<SequentialType>(*GTI)) { + // If the src gep ends with a constant array index, merge this get into + // it, even if we have a non-zero array index. + Indices.insert(Indices.end(), SrcGEPOperands.begin()+1, + SrcGEPOperands.end()-1); + Indices.insert(Indices.end(), GEP.idx_begin(), GEP.idx_end()); + } } if (!Indices.empty()) @@ -2428,7 +2515,7 @@ Instruction *InstCombiner::visitAllocationInst(AllocationInst &AI) { // Now that I is pointing to the first non-allocation-inst in the block, // insert our getelementptr instruction... // - std::vector<Value*> Idx(2, Constant::getNullValue(Type::LongTy)); + std::vector<Value*> Idx(2, Constant::getNullValue(Type::IntTy)); Value *V = new GetElementPtrInst(New, Idx, New->getName()+".sub", It); // Now make everything use the getelementptr instead of the original @@ -2469,7 +2556,7 @@ Instruction *InstCombiner::visitFreeInst(FreeInst &FI) { /// expression, or null if something is funny. /// static Constant *GetGEPGlobalInitializer(Constant *C, ConstantExpr *CE) { - if (CE->getOperand(1) != Constant::getNullValue(Type::LongTy)) + if (CE->getOperand(1) != Constant::getNullValue(CE->getOperand(1)->getType())) return 0; // Do not allow stepping over the value! // Loop over all of the operands, tracking down which value we are diff --git a/lib/Transforms/Scalar/SCCP.cpp b/lib/Transforms/Scalar/SCCP.cpp index 75be397..8d550b8 100644 --- a/lib/Transforms/Scalar/SCCP.cpp +++ b/lib/Transforms/Scalar/SCCP.cpp @@ -712,7 +712,7 @@ void SCCP::visitGetElementPtrInst(GetElementPtrInst &I) { /// null if something is funny. /// static Constant *GetGEPGlobalInitializer(Constant *C, ConstantExpr *CE) { - if (CE->getOperand(1) != Constant::getNullValue(Type::LongTy)) + if (CE->getOperand(1) != Constant::getNullValue(CE->getOperand(1)->getType())) return 0; // Do not allow stepping over the value! // Loop over all of the operands, tracking down which value we are diff --git a/lib/Transforms/Scalar/ScalarReplAggregates.cpp b/lib/Transforms/Scalar/ScalarReplAggregates.cpp index c1c4759..9598918 100644 --- a/lib/Transforms/Scalar/ScalarReplAggregates.cpp +++ b/lib/Transforms/Scalar/ScalarReplAggregates.cpp @@ -193,7 +193,7 @@ bool SROA::performScalarRepl(Function &F) { // std::string OldName = GEPI->getName(); // Steal the old name... std::vector<Value*> NewArgs; - NewArgs.push_back(Constant::getNullValue(Type::LongTy)); + NewArgs.push_back(Constant::getNullValue(Type::IntTy)); NewArgs.insert(NewArgs.end(), GEPI->op_begin()+3, GEPI->op_end()); GEPI->setName(""); RepValue = diff --git a/lib/Transforms/TransformInternals.cpp b/lib/Transforms/TransformInternals.cpp index 9039f59..971a58d 100644 --- a/lib/Transforms/TransformInternals.cpp +++ b/lib/Transforms/TransformInternals.cpp @@ -35,8 +35,7 @@ static const Type *getStructOffsetStep(const StructType *STy, uint64_t &Offset, (i == SL->MemberOffsets.size()-1 || Offset < SL->MemberOffsets[i+1])); // Make sure to save the current index... - // FIXME for PR82 - Indices.push_back(ConstantUInt::get(Type::UByteTy, i)); + Indices.push_back(ConstantUInt::get(Type::UIntTy, i)); Offset = SL->MemberOffsets[i]; return STy->getContainedType(i); } @@ -75,8 +74,10 @@ const Type *llvm::getStructOffsetType(const Type *Ty, unsigned &Offset, NextType = ATy->getElementType(); unsigned ChildSize = TD.getTypeSize(NextType); - // FIXME for PR82 - Indices.push_back(ConstantSInt::get(Type::LongTy, Offset/ChildSize)); + if (ConstantSInt::isValueValidForType(Type::IntTy, Offset/ChildSize)) + Indices.push_back(ConstantSInt::get(Type::IntTy, Offset/ChildSize)); + else + Indices.push_back(ConstantSInt::get(Type::LongTy, Offset/ChildSize)); ThisOffset = (Offset/ChildSize)*ChildSize; } else { Offset = 0; // Return the offset that we were able to achieve @@ -99,105 +100,6 @@ const Type *llvm::ConvertibleToGEP(const Type *Ty, Value *OffsetVal, std::vector<Value*> &Indices, const TargetData &TD, BasicBlock::iterator *BI) { - const CompositeType *CompTy = dyn_cast<CompositeType>(Ty); - if (CompTy == 0) return 0; - - // See if the cast is of an integer expression that is either a constant, - // or a value scaled by some amount with a possible offset. - // - ExprType Expr = ClassifyExpr(OffsetVal); - - // Get the offset and scale values if they exists... - // A scale of zero with Expr.Var != 0 means a scale of 1. - // - int64_t Offset = Expr.Offset ? getConstantValue(Expr.Offset) : 0; - int64_t Scale = Expr.Scale ? getConstantValue(Expr.Scale) : 0; - - if (Expr.Var && Scale == 0) Scale = 1; // Scale != 0 if Expr.Var != 0 - - // Loop over the Scale and Offset values, filling in the Indices vector for - // our final getelementptr instruction. - // - const Type *NextTy = CompTy; - do { - if (!isa<CompositeType>(NextTy)) - return 0; // Type must not be ready for processing... - CompTy = cast<CompositeType>(NextTy); - - if (const StructType *StructTy = dyn_cast<StructType>(CompTy)) { - // Step into the appropriate element of the structure... - uint64_t ActualOffset = (Offset < 0) ? 0 : (uint64_t)Offset; - NextTy = getStructOffsetStep(StructTy, ActualOffset, Indices, TD); - Offset -= ActualOffset; - } else { - const Type *ElTy = cast<SequentialType>(CompTy)->getElementType(); - if (!ElTy->isSized() || (isa<PointerType>(CompTy) && !Indices.empty())) - return 0; // Type is unreasonable... escape! - unsigned ElSize = TD.getTypeSize(ElTy); - if (ElSize == 0) return 0; // Avoid division by zero... - int64_t ElSizeS = ElSize; - - // See if the user is indexing into a different cell of this array... - if (Scale && (Scale >= ElSizeS || -Scale >= ElSizeS)) { - // A scale n*ElSize might occur if we are not stepping through - // array by one. In this case, we will have to insert math to munge - // the index. - // - int64_t ScaleAmt = Scale/ElSizeS; - if (Scale-ScaleAmt*ElSizeS) - return 0; // Didn't scale by a multiple of element size, bail out - Scale = 0; // Scale is consumed - - int64_t Index = Offset/ElSize; // is zero unless Offset > ElSize - Offset -= Index*ElSize; // Consume part of the offset - - if (BI) { // Generate code? - BasicBlock *BB = (*BI)->getParent(); - if (Expr.Var->getType() != Type::LongTy) // FIXME for PR82 - Expr.Var = new CastInst(Expr.Var, Type::LongTy, // FIXME for PR82 - Expr.Var->getName()+"-idxcast", *BI); - - if (ScaleAmt && ScaleAmt != 1) { - // If we have to scale up our index, do so now - // FIXME for PR82 - Value *ScaleAmtVal = ConstantSInt::get(Type::LongTy, ScaleAmt); - Expr.Var = BinaryOperator::create(Instruction::Mul, Expr.Var, - ScaleAmtVal, - Expr.Var->getName()+"-scale",*BI); - } - - if (Index) { // Add an offset to the index - // FIXME for PR82 - Value *IndexAmt = ConstantSInt::get(Type::LongTy, Index); - Expr.Var = BinaryOperator::create(Instruction::Add, Expr.Var, - IndexAmt, - Expr.Var->getName()+"-offset", - *BI); - } - } - - Indices.push_back(Expr.Var); - Expr.Var = 0; - } else if (Offset >= (int64_t)ElSize || -Offset >= (int64_t)ElSize) { - // Calculate the index that we are entering into the array cell with - uint64_t Index = Offset/ElSize; - // FIXME for PR82 - Indices.push_back(ConstantSInt::get(Type::LongTy, Index)); - Offset -= (int64_t)(Index*ElSize); // Consume part of the offset - - } else if (isa<ArrayType>(CompTy) || Indices.empty()) { - // Must be indexing a small amount into the first cell of the array - // Just index into element zero of the array here. - // - // FIXME for PR82 - Indices.push_back(ConstantSInt::get(Type::LongTy, 0)); - } else { - return 0; // Hrm. wierd, can't handle this case. Bail - } - NextTy = ElTy; - } - } while (Offset || Scale); // Go until we're done! - - return NextTy; + return 0; } diff --git a/lib/Transforms/Utils/LowerInvoke.cpp b/lib/Transforms/Utils/LowerInvoke.cpp index 2349d76..c486633 100644 --- a/lib/Transforms/Utils/LowerInvoke.cpp +++ b/lib/Transforms/Utils/LowerInvoke.cpp @@ -277,14 +277,14 @@ bool LowerInvoke::insertExpensiveEHSupport(Function &F) { // Store this old value as our 'next' field, and store our alloca as the // current jblist. std::vector<Value*> Idx; - Idx.push_back(Constant::getNullValue(Type::LongTy)); - Idx.push_back(ConstantUInt::get(Type::UByteTy, 0)); + Idx.push_back(Constant::getNullValue(Type::IntTy)); + Idx.push_back(ConstantUInt::get(Type::UIntTy, 0)); Value *NextFieldPtr = new GetElementPtrInst(JmpBuf, Idx, "NextField", II); new StoreInst(OldEntry, NextFieldPtr, II); new StoreInst(JmpBuf, JBListHead, II); // Call setjmp, passing in the address of the jmpbuffer. - Idx[1] = ConstantUInt::get(Type::UByteTy, 1); + Idx[1] = ConstantUInt::get(Type::UIntTy, 1); Value *JmpBufPtr = new GetElementPtrInst(JmpBuf, Idx, "TheJmpBuf", II); Value *SJRet = new CallInst(SetJmpFn, JmpBufPtr, "sjret", II); @@ -369,14 +369,14 @@ bool LowerInvoke::insertExpensiveEHSupport(Function &F) { // JBList. std::vector<Value*> Idx; Idx.push_back(Constant::getNullValue(Type::LongTy)); - Idx.push_back(ConstantUInt::get(Type::UByteTy, 0)); + Idx.push_back(ConstantUInt::get(Type::UIntTy, 0)); Value *NextFieldPtr = new GetElementPtrInst(RecPtr, Idx, "NextField", RI); Value *NextRec = new LoadInst(NextFieldPtr, "NextRecord", RI); new StoreInst(NextRec, JBListHead, RI); // Now that we popped the top of the JBList, get a pointer to the jmpbuf and // longjmp. - Idx[1] = ConstantUInt::get(Type::UByteTy, 1); + Idx[1] = ConstantUInt::get(Type::UIntTy, 1); Idx[0] = new GetElementPtrInst(RecPtr, Idx, "JmpBuf", RI); Idx[1] = ConstantInt::get(Type::IntTy, 1); new CallInst(LongJmpFn, Idx, "", RI); |