diff options
Diffstat (limited to 'lib/Transforms')
23 files changed, 492 insertions, 453 deletions
diff --git a/lib/Transforms/IPO/ArgumentPromotion.cpp b/lib/Transforms/IPO/ArgumentPromotion.cpp index 5183d43..79f21b5 100644 --- a/lib/Transforms/IPO/ArgumentPromotion.cpp +++ b/lib/Transforms/IPO/ArgumentPromotion.cpp @@ -307,8 +307,8 @@ namespace { unsigned idx = 0; for (; idx < LHS.size() && idx < RHS.size(); ++idx) { if (LHS[idx] != RHS[idx]) { - return cast<ConstantInt>(LHS[idx])->getRawValue() < - cast<ConstantInt>(RHS[idx])->getRawValue(); + return cast<ConstantInt>(LHS[idx])->getZExtValue() < + cast<ConstantInt>(RHS[idx])->getZExtValue(); } } @@ -518,7 +518,7 @@ Function *ArgPromotion::DoPromotion(Function *F, std::string NewName = I->getName(); for (unsigned i = 0, e = Operands.size(); i != e; ++i) if (ConstantInt *CI = dyn_cast<ConstantInt>(Operands[i])) - NewName += "."+itostr((int64_t)CI->getRawValue()); + NewName += "."+itostr((int64_t)CI->getZExtValue()); else NewName += ".x"; TheArg->setName(NewName+".val"); diff --git a/lib/Transforms/IPO/GlobalOpt.cpp b/lib/Transforms/IPO/GlobalOpt.cpp index 5abd290..fc39fe8 100644 --- a/lib/Transforms/IPO/GlobalOpt.cpp +++ b/lib/Transforms/IPO/GlobalOpt.cpp @@ -270,7 +270,7 @@ static bool AnalyzeGlobal(Value *V, GlobalStatus &GS, static Constant *getAggregateConstantElement(Constant *Agg, Constant *Idx) { ConstantInt *CI = dyn_cast<ConstantInt>(Idx); if (!CI) return 0; - unsigned IdxV = (unsigned)CI->getRawValue(); + unsigned IdxV = CI->getZExtValue(); if (ConstantStruct *CS = dyn_cast<ConstantStruct>(Agg)) { if (IdxV < CS->getNumOperands()) return CS->getOperand(IdxV); @@ -384,7 +384,7 @@ static GlobalVariable *SRAGlobal(GlobalVariable *GV) { NewGlobals.reserve(STy->getNumElements()); for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) { Constant *In = getAggregateConstantElement(Init, - ConstantUInt::get(Type::UIntTy, i)); + ConstantInt::get(Type::UIntTy, i)); assert(In && "Couldn't get element of initializer?"); GlobalVariable *NGV = new GlobalVariable(STy->getElementType(i), false, GlobalVariable::InternalLinkage, @@ -406,7 +406,7 @@ static GlobalVariable *SRAGlobal(GlobalVariable *GV) { NewGlobals.reserve(NumElements); for (unsigned i = 0, e = NumElements; i != e; ++i) { Constant *In = getAggregateConstantElement(Init, - ConstantUInt::get(Type::UIntTy, i)); + ConstantInt::get(Type::UIntTy, i)); assert(In && "Couldn't get element of initializer?"); GlobalVariable *NGV = new GlobalVariable(STy->getElementType(), false, @@ -435,8 +435,7 @@ static GlobalVariable *SRAGlobal(GlobalVariable *GV) { // Ignore the 1th operand, which has to be zero or else the program is quite // broken (undefined). Get the 2nd operand, which is the structure or array // index. - unsigned Val = - (unsigned)cast<ConstantInt>(GEP->getOperand(2))->getRawValue(); + unsigned Val = cast<ConstantInt>(GEP->getOperand(2))->getZExtValue(); if (Val >= NewGlobals.size()) Val = 0; // Out of bound array access. Value *NewPtr = NewGlobals[Val]; @@ -673,11 +672,11 @@ static GlobalVariable *OptimizeGlobalAddressOfMalloc(GlobalVariable *GV, DEBUG(std::cerr << "PROMOTING MALLOC GLOBAL: " << *GV << " MALLOC = " <<*MI); ConstantInt *NElements = cast<ConstantInt>(MI->getArraySize()); - if (NElements->getRawValue() != 1) { + if (NElements->getZExtValue() != 1) { // If we have an array allocation, transform it to a single element // allocation to make the code below simpler. Type *NewTy = ArrayType::get(MI->getAllocatedType(), - (unsigned)NElements->getRawValue()); + NElements->getZExtValue()); MallocInst *NewMI = new MallocInst(NewTy, Constant::getNullValue(Type::UIntTy), MI->getAlignment(), MI->getName(), MI); @@ -886,11 +885,12 @@ static void RewriteUsesOfLoadForHeapSRoA(LoadInst *Ptr, // Otherwise, this should be: 'getelementptr Ptr, Idx, uint FieldNo ...' GetElementPtrInst *GEPI = cast<GetElementPtrInst>(User); - assert(GEPI->getNumOperands() >= 3 && isa<ConstantUInt>(GEPI->getOperand(2)) + assert(GEPI->getNumOperands() >= 3 && isa<ConstantInt>(GEPI->getOperand(2)) + && GEPI->getOperand(2)->getType()->isUnsigned() && "Unexpected GEPI!"); // Load the pointer for this field. - unsigned FieldNo = cast<ConstantUInt>(GEPI->getOperand(2))->getValue(); + unsigned FieldNo = cast<ConstantInt>(GEPI->getOperand(2))->getZExtValue(); if (InsertedLoadsForPtr.size() <= FieldNo) InsertedLoadsForPtr.resize(FieldNo+1); if (InsertedLoadsForPtr[FieldNo] == 0) @@ -1088,7 +1088,7 @@ static bool OptimizeOnceStoredGlobal(GlobalVariable *GV, Value *StoredOnceVal, // Restrict this transformation to only working on small allocations // (2048 bytes currently), as we don't want to introduce a 16M global or // something. - if (NElements->getRawValue()* + if (NElements->getZExtValue()* TD.getTypeSize(MI->getAllocatedType()) < 2048) { GVI = OptimizeGlobalAddressOfMalloc(GV, MI); return true; @@ -1431,7 +1431,7 @@ GlobalVariable *GlobalOpt::FindGlobalCtors(Module &M) { // Init priority must be standard. ConstantInt *CI = dyn_cast<ConstantInt>(CS->getOperand(0)); - if (!CI || CI->getRawValue() != 65535) + if (!CI || CI->getZExtValue() != 65535) return 0; } else { return 0; @@ -1461,7 +1461,7 @@ static GlobalVariable *InstallGlobalCtors(GlobalVariable *GCL, const std::vector<Function*> &Ctors) { // If we made a change, reassemble the initializer list. std::vector<Constant*> CSVals; - CSVals.push_back(ConstantSInt::get(Type::IntTy, 65535)); + CSVals.push_back(ConstantInt::get(Type::IntTy, 65535)); CSVals.push_back(0); // Create the new init list. @@ -1474,7 +1474,7 @@ static GlobalVariable *InstallGlobalCtors(GlobalVariable *GCL, std::vector<const Type*>(), false); const PointerType *PFTy = PointerType::get(FTy); CSVals[1] = Constant::getNullValue(PFTy); - CSVals[0] = ConstantSInt::get(Type::IntTy, 2147483647); + CSVals[0] = ConstantInt::get(Type::IntTy, 2147483647); } CAList.push_back(ConstantStruct::get(CSVals)); } @@ -1575,10 +1575,9 @@ static Constant *EvaluateStoreInto(Constant *Init, Constant *Val, } // Replace the element that we are supposed to. - ConstantUInt *CU = cast<ConstantUInt>(Addr->getOperand(OpNo)); - assert(CU->getValue() < STy->getNumElements() && - "Struct index out of range!"); - unsigned Idx = (unsigned)CU->getValue(); + ConstantInt *CU = cast<ConstantInt>(Addr->getOperand(OpNo)); + unsigned Idx = CU->getZExtValue(); + assert(Idx < STy->getNumElements() && "Struct index out of range!"); Elts[Idx] = EvaluateStoreInto(Elts[Idx], Val, Addr, OpNo+1); // Return the modified struct. @@ -1603,9 +1602,9 @@ static Constant *EvaluateStoreInto(Constant *Init, Constant *Val, " ConstantFoldLoadThroughGEPConstantExpr"); } - assert((uint64_t)CI->getRawValue() < ATy->getNumElements()); - Elts[(uint64_t)CI->getRawValue()] = - EvaluateStoreInto(Elts[(uint64_t)CI->getRawValue()], Val, Addr, OpNo+1); + assert(CI->getZExtValue() < ATy->getNumElements()); + Elts[CI->getZExtValue()] = + EvaluateStoreInto(Elts[CI->getZExtValue()], Val, Addr, OpNo+1); return ConstantArray::get(ATy, Elts); } } diff --git a/lib/Transforms/IPO/LowerSetJmp.cpp b/lib/Transforms/IPO/LowerSetJmp.cpp index 8018553..cd46718 100644 --- a/lib/Transforms/IPO/LowerSetJmp.cpp +++ b/lib/Transforms/IPO/LowerSetJmp.cpp @@ -378,7 +378,7 @@ void LowerSetJmp::TransformSetJmpCall(CallInst* Inst) CastInst* BufPtr = new CastInst(Inst->getOperand(1), SBPTy, "SBJmpBuf", Inst); new CallInst(AddSJToMap, make_vector<Value*>(GetSetJmpMap(Func), BufPtr, - ConstantUInt::get(Type::UIntTy, + ConstantInt::get(Type::UIntTy, SetJmpIDMap[Func]++), 0), "", Inst); @@ -429,7 +429,7 @@ void LowerSetJmp::TransformSetJmpCall(CallInst* Inst) // Add the case for this setjmp's number... SwitchValuePair SVP = GetSJSwitch(Func, GetRethrowBB(Func)); - SVP.first->addCase(ConstantUInt::get(Type::UIntTy, SetJmpIDMap[Func] - 1), + SVP.first->addCase(ConstantInt::get(Type::UIntTy, SetJmpIDMap[Func] - 1), SetJmpContBlock); // Value coming from the handling of the exception. diff --git a/lib/Transforms/IPO/SimplifyLibCalls.cpp b/lib/Transforms/IPO/SimplifyLibCalls.cpp index 9f9c527..23f3352 100644 --- a/lib/Transforms/IPO/SimplifyLibCalls.cpp +++ b/lib/Transforms/IPO/SimplifyLibCalls.cpp @@ -517,8 +517,8 @@ public: std::vector<Value*> vals; vals.push_back(gep); // destination vals.push_back(ci->getOperand(2)); // source - vals.push_back(ConstantUInt::get(SLC.getIntPtrType(),len)); // length - vals.push_back(ConstantUInt::get(Type::UIntTy,1)); // alignment + vals.push_back(ConstantInt::get(SLC.getIntPtrType(),len)); // length + vals.push_back(ConstantInt::get(Type::UIntTy,1)); // alignment new CallInst(SLC.get_memcpy(), vals, "", ci); // Finally, substitute the first operand of the strcat call for the @@ -556,38 +556,38 @@ public: // Check that the first argument to strchr is a constant array of sbyte. // If it is, get the length and data, otherwise return false. uint64_t len = 0; - ConstantArray* CA; + ConstantArray* CA = 0; if (!getConstantStringLength(ci->getOperand(1),len,&CA)) return false; - // Check that the second argument to strchr is a constant int, return false - // if it isn't - ConstantSInt* CSI = dyn_cast<ConstantSInt>(ci->getOperand(2)); - if (!CSI) { - // Just lower this to memchr since we know the length of the string as - // it is constant. + // Check that the second argument to strchr is a constant int. If it isn't + // a constant signed integer, we can try an alternate optimization + ConstantInt* CSI = dyn_cast<ConstantInt>(ci->getOperand(2)); + if (!CSI || CSI->getType()->isUnsigned() ) { + // The second operand is not constant, or not signed. Just lower this to + // memchr since we know the length of the string since it is constant. Function* f = SLC.get_memchr(); std::vector<Value*> args; args.push_back(ci->getOperand(1)); args.push_back(ci->getOperand(2)); - args.push_back(ConstantUInt::get(SLC.getIntPtrType(),len)); + args.push_back(ConstantInt::get(SLC.getIntPtrType(),len)); ci->replaceAllUsesWith( new CallInst(f,args,ci->getName(),ci)); ci->eraseFromParent(); return true; } // Get the character we're looking for - int64_t chr = CSI->getValue(); + int64_t chr = CSI->getSExtValue(); // Compute the offset uint64_t offset = 0; bool char_found = false; for (uint64_t i = 0; i < len; ++i) { - if (ConstantSInt* CI = dyn_cast<ConstantSInt>(CA->getOperand(i))) { + if (ConstantInt* CI = dyn_cast<ConstantInt>(CA->getOperand(i))) { // Check for the null terminator if (CI->isNullValue()) break; // we found end of string - else if (CI->getValue() == chr) { + else if (CI->getSExtValue() == chr) { char_found = true; offset = i; break; @@ -599,7 +599,7 @@ public: // (if c is a constant integer and s is a constant string) if (char_found) { std::vector<Value*> indices; - indices.push_back(ConstantUInt::get(Type::ULongTy,offset)); + indices.push_back(ConstantInt::get(Type::ULongTy,offset)); GetElementPtrInst* GEP = new GetElementPtrInst(ci->getOperand(1),indices, ci->getOperand(1)->getName()+".strchr",ci); ci->replaceAllUsesWith(GEP); @@ -679,7 +679,7 @@ public: std::string str1 = A1->getAsString(); std::string str2 = A2->getAsString(); int result = strcmp(str1.c_str(), str2.c_str()); - ci->replaceAllUsesWith(ConstantSInt::get(Type::IntTy,result)); + ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,result)); ci->eraseFromParent(); return true; } @@ -723,7 +723,7 @@ public: bool len_arg_is_const = false; if (ConstantInt* len_CI = dyn_cast<ConstantInt>(ci->getOperand(3))) { len_arg_is_const = true; - len_arg = len_CI->getRawValue(); + len_arg = len_CI->getZExtValue(); if (len_arg == 0) { // strncmp(x,y,0) -> 0 ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,0)); @@ -769,7 +769,7 @@ public: std::string str1 = A1->getAsString(); std::string str2 = A2->getAsString(); int result = strncmp(str1.c_str(), str2.c_str(), len_arg); - ci->replaceAllUsesWith(ConstantSInt::get(Type::IntTy,result)); + ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,result)); ci->eraseFromParent(); return true; } @@ -843,8 +843,8 @@ public: std::vector<Value*> vals; vals.push_back(dest); // destination vals.push_back(src); // source - vals.push_back(ConstantUInt::get(SLC.getIntPtrType(),len)); // length - vals.push_back(ConstantUInt::get(Type::UIntTy,1)); // alignment + vals.push_back(ConstantInt::get(SLC.getIntPtrType(),len)); // length + vals.push_back(ConstantInt::get(Type::UIntTy,1)); // alignment new CallInst(SLC.get_memcpy(), vals, "", ci); // Finally, substitute the first operand of the strcat call for the @@ -891,7 +891,7 @@ struct StrLenOptimization : public LibCallOptimization { if (ConstantInt* CI = dyn_cast<ConstantInt>(bop->getOperand(1))) { // Get the value the strlen result is compared to - uint64_t val = CI->getRawValue(); + uint64_t val = CI->getZExtValue(); // If its compared against length 0 with == or != if (val == 0 && @@ -902,7 +902,7 @@ struct StrLenOptimization : public LibCallOptimization { // strlen(x) == 0 -> *x == 0 LoadInst* load = new LoadInst(str,str->getName()+".first",ci); BinaryOperator* rbop = BinaryOperator::create(bop->getOpcode(), - load, ConstantSInt::get(Type::SByteTy,0), + load, ConstantInt::get(Type::SByteTy,0), bop->getName()+".strlen", ci); bop->replaceAllUsesWith(rbop); bop->eraseFromParent(); @@ -919,9 +919,9 @@ struct StrLenOptimization : public LibCallOptimization { // strlen("xyz") -> 3 (for example) const Type *Ty = SLC.getTargetData()->getIntPtrType(); if (Ty->isSigned()) - ci->replaceAllUsesWith(ConstantSInt::get(Ty, len)); + ci->replaceAllUsesWith(ConstantInt::get(Ty, len)); else - ci->replaceAllUsesWith(ConstantUInt::get(Ty, len)); + ci->replaceAllUsesWith(ConstantInt::get(Ty, len)); ci->eraseFromParent(); return true; @@ -985,7 +985,7 @@ struct memcmpOptimization : public LibCallOptimization { // Make sure we have a constant length. ConstantInt *LenC = dyn_cast<ConstantInt>(CI->getOperand(3)); if (!LenC) return false; - uint64_t Len = LenC->getRawValue(); + uint64_t Len = LenC->getZExtValue(); // If the length is zero, this returns 0. switch (Len) { @@ -1075,8 +1075,8 @@ struct LLVMMemCpyMoveOptzn : public LibCallOptimization { return false; // If the length is larger than the alignment, we can't optimize - uint64_t len = LEN->getRawValue(); - uint64_t alignment = ALIGN->getRawValue(); + uint64_t len = LEN->getZExtValue(); + uint64_t alignment = ALIGN->getZExtValue(); if (alignment == 0) alignment = 1; // Alignment 0 is identity for alignment 1 if (len > alignment) @@ -1154,8 +1154,8 @@ struct LLVMMemSetOptimization : public LibCallOptimization { return false; // Extract the length and alignment - uint64_t len = LEN->getRawValue(); - uint64_t alignment = ALIGN->getRawValue(); + uint64_t len = LEN->getZExtValue(); + uint64_t alignment = ALIGN->getZExtValue(); // Alignment 0 is identity for alignment 1 if (alignment == 0) @@ -1174,7 +1174,7 @@ struct LLVMMemSetOptimization : public LibCallOptimization { // Make sure we have a constant ubyte to work with so we can extract // the value to be filled. - ConstantUInt* FILL = dyn_cast<ConstantUInt>(ci->getOperand(2)); + ConstantInt* FILL = dyn_cast<ConstantInt>(ci->getOperand(2)); if (!FILL) return false; if (FILL->getType() != Type::UByteTy) @@ -1183,7 +1183,7 @@ struct LLVMMemSetOptimization : public LibCallOptimization { // memset(s,c,n) -> store s, c (for n=1,2,4,8) // Extract the fill character - uint64_t fill_char = FILL->getValue(); + uint64_t fill_char = FILL->getZExtValue(); uint64_t fill_value = fill_char; // Get the type we will cast to, based on size of memory area to fill, and @@ -1215,7 +1215,7 @@ struct LLVMMemSetOptimization : public LibCallOptimization { // Cast dest to the right sized primitive and then load/store CastInst* DestCast = new CastInst(dest,PointerType::get(castType),dest->getName()+".cast",ci); - new StoreInst(ConstantUInt::get(castType,fill_value),DestCast, ci); + new StoreInst(ConstantInt::get(castType,fill_value),DestCast, ci); ci->eraseFromParent(); return true; } @@ -1325,16 +1325,16 @@ public: // The first character has to be a % if (ConstantInt* CI = dyn_cast<ConstantInt>(CA->getOperand(0))) - if (CI->getRawValue() != '%') + if (CI->getZExtValue() != '%') return false; // Get the second character and switch on its value ConstantInt* CI = dyn_cast<ConstantInt>(CA->getOperand(1)); - switch (CI->getRawValue()) { + switch (CI->getZExtValue()) { case 's': { if (len != 3 || - dyn_cast<ConstantInt>(CA->getOperand(2))->getRawValue() != '\n') + dyn_cast<ConstantInt>(CA->getOperand(2))->getZExtValue() != '\n') return false; // printf("%s\n",str) -> puts(str) @@ -1344,7 +1344,7 @@ public: std::vector<Value*> args; args.push_back(CastToCStr(ci->getOperand(2), *ci)); new CallInst(puts_func,args,ci->getName(),ci); - ci->replaceAllUsesWith(ConstantSInt::get(Type::IntTy,len)); + ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,len)); break; } case 'c': @@ -1359,7 +1359,7 @@ public: CastInst* cast = new CastInst(ci->getOperand(2), Type::IntTy, CI->getName()+".int", ci); new CallInst(putchar_func, cast, "", ci); - ci->replaceAllUsesWith(ConstantSInt::get(Type::IntTy, 1)); + ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy, 1)); break; } default: @@ -1409,7 +1409,7 @@ public: for (unsigned i = 0; i < len; ++i) { if (ConstantInt* CI = dyn_cast<ConstantInt>(CA->getOperand(i))) { // Check for the null terminator - if (CI->getRawValue() == '%') + if (CI->getZExtValue() == '%') return false; // we found end of string } else { return false; @@ -1430,11 +1430,11 @@ public: std::vector<Value*> args; args.push_back(ci->getOperand(2)); - args.push_back(ConstantUInt::get(SLC.getIntPtrType(),len)); - args.push_back(ConstantUInt::get(SLC.getIntPtrType(),1)); + args.push_back(ConstantInt::get(SLC.getIntPtrType(),len)); + args.push_back(ConstantInt::get(SLC.getIntPtrType(),1)); args.push_back(ci->getOperand(1)); new CallInst(fwrite_func,args,ci->getName(),ci); - ci->replaceAllUsesWith(ConstantSInt::get(Type::IntTy,len)); + ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,len)); ci->eraseFromParent(); return true; } @@ -1446,12 +1446,12 @@ public: // The first character has to be a % if (ConstantInt* CI = dyn_cast<ConstantInt>(CA->getOperand(0))) - if (CI->getRawValue() != '%') + if (CI->getZExtValue() != '%') return false; // Get the second character and switch on its value ConstantInt* CI = dyn_cast<ConstantInt>(CA->getOperand(1)); - switch (CI->getRawValue()) { + switch (CI->getZExtValue()) { case 's': { uint64_t len = 0; @@ -1464,11 +1464,11 @@ public: return false; std::vector<Value*> args; args.push_back(CastToCStr(ci->getOperand(3), *ci)); - args.push_back(ConstantUInt::get(SLC.getIntPtrType(),len)); - args.push_back(ConstantUInt::get(SLC.getIntPtrType(),1)); + args.push_back(ConstantInt::get(SLC.getIntPtrType(),len)); + args.push_back(ConstantInt::get(SLC.getIntPtrType(),1)); args.push_back(ci->getOperand(1)); new CallInst(fwrite_func,args,ci->getName(),ci); - ci->replaceAllUsesWith(ConstantSInt::get(Type::IntTy,len)); + ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,len)); } else { // fprintf(file,"%s",str) -> fputs(str,file) const Type* FILEptr_type = ci->getOperand(1)->getType(); @@ -1479,7 +1479,7 @@ public: args.push_back(CastToCStr(ci->getOperand(3), *ci)); args.push_back(ci->getOperand(1)); new CallInst(fputs_func,args,ci->getName(),ci); - ci->replaceAllUsesWith(ConstantSInt::get(Type::IntTy,len)); + ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,len)); } break; } @@ -1493,7 +1493,7 @@ public: CastInst* cast = new CastInst(ci->getOperand(3), Type::IntTy, CI->getName()+".int", ci); new CallInst(fputc_func,cast,ci->getOperand(1),"",ci); - ci->replaceAllUsesWith(ConstantSInt::get(Type::IntTy,1)); + ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,1)); break; } default: @@ -1537,7 +1537,7 @@ public: if (len == 0) { // If the length is 0, we just need to store a null byte new StoreInst(ConstantInt::get(Type::SByteTy,0),ci->getOperand(1),ci); - ci->replaceAllUsesWith(ConstantSInt::get(Type::IntTy,0)); + ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,0)); ci->eraseFromParent(); return true; } @@ -1546,7 +1546,7 @@ public: for (unsigned i = 0; i < len; ++i) { if (ConstantInt* CI = dyn_cast<ConstantInt>(CA->getOperand(i))) { // Check for the null terminator - if (CI->getRawValue() == '%') + if (CI->getZExtValue() == '%') return false; // we found a %, can't optimize } else { return false; // initializer is not constant int, can't optimize @@ -1563,10 +1563,10 @@ public: std::vector<Value*> args; args.push_back(ci->getOperand(1)); args.push_back(ci->getOperand(2)); - args.push_back(ConstantUInt::get(SLC.getIntPtrType(),len)); - args.push_back(ConstantUInt::get(Type::UIntTy,1)); + args.push_back(ConstantInt::get(SLC.getIntPtrType(),len)); + args.push_back(ConstantInt::get(Type::UIntTy,1)); new CallInst(memcpy_func,args,"",ci); - ci->replaceAllUsesWith(ConstantSInt::get(Type::IntTy,len)); + ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,len)); ci->eraseFromParent(); return true; } @@ -1578,12 +1578,12 @@ public: // The first character has to be a % if (ConstantInt* CI = dyn_cast<ConstantInt>(CA->getOperand(0))) - if (CI->getRawValue() != '%') + if (CI->getZExtValue() != '%') return false; // Get the second character and switch on its value ConstantInt* CI = dyn_cast<ConstantInt>(CA->getOperand(1)); - switch (CI->getRawValue()) { + switch (CI->getZExtValue()) { case 's': { // sprintf(dest,"%s",str) -> llvm.memcpy(dest, str, strlen(str)+1, 1) Function* strlen_func = SLC.get_strlen(); @@ -1602,7 +1602,7 @@ public: args.push_back(CastToCStr(ci->getOperand(1), *ci)); args.push_back(CastToCStr(ci->getOperand(3), *ci)); args.push_back(Len1); - args.push_back(ConstantUInt::get(Type::UIntTy,1)); + args.push_back(ConstantInt::get(Type::UIntTy,1)); new CallInst(memcpy_func, args, "", ci); // The strlen result is the unincremented number of bytes in the string. @@ -1619,10 +1619,10 @@ public: CastInst* cast = new CastInst(ci->getOperand(3),Type::SByteTy,"char",ci); new StoreInst(cast, ci->getOperand(1), ci); GetElementPtrInst* gep = new GetElementPtrInst(ci->getOperand(1), - ConstantUInt::get(Type::UIntTy,1),ci->getOperand(1)->getName()+".end", + ConstantInt::get(Type::UIntTy,1),ci->getOperand(1)->getName()+".end", ci); new StoreInst(ConstantInt::get(Type::SByteTy,0),gep,ci); - ci->replaceAllUsesWith(ConstantSInt::get(Type::IntTy,1)); + ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,1)); ci->eraseFromParent(); return true; } @@ -1686,8 +1686,8 @@ public: return false; std::vector<Value*> parms; parms.push_back(ci->getOperand(1)); - parms.push_back(ConstantUInt::get(SLC.getIntPtrType(),len)); - parms.push_back(ConstantUInt::get(SLC.getIntPtrType(),1)); + parms.push_back(ConstantInt::get(SLC.getIntPtrType(),len)); + parms.push_back(ConstantInt::get(SLC.getIntPtrType(),1)); parms.push_back(ci->getOperand(2)); new CallInst(fwrite_func,parms,"",ci); break; @@ -1716,11 +1716,11 @@ public: virtual bool OptimizeCall(CallInst *ci, SimplifyLibCalls &SLC) { if (ConstantInt* CI = dyn_cast<ConstantInt>(ci->getOperand(1))) { // isdigit(c) -> 0 or 1, if 'c' is constant - uint64_t val = CI->getRawValue(); + uint64_t val = CI->getZExtValue(); if (val >= '0' && val <='9') - ci->replaceAllUsesWith(ConstantSInt::get(Type::IntTy,1)); + ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,1)); else - ci->replaceAllUsesWith(ConstantSInt::get(Type::IntTy,0)); + ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,0)); ci->eraseFromParent(); return true; } @@ -1730,10 +1730,10 @@ public: new CastInst(ci->getOperand(1),Type::UIntTy, ci->getOperand(1)->getName()+".uint",ci); BinaryOperator* sub_inst = BinaryOperator::createSub(cast, - ConstantUInt::get(Type::UIntTy,0x30), + ConstantInt::get(Type::UIntTy,0x30), ci->getOperand(1)->getName()+".sub",ci); SetCondInst* setcond_inst = new SetCondInst(Instruction::SetLE,sub_inst, - ConstantUInt::get(Type::UIntTy,9), + ConstantInt::get(Type::UIntTy,9), ci->getOperand(1)->getName()+".cmp",ci); CastInst* c2 = new CastInst(setcond_inst,Type::IntTy, @@ -1760,7 +1760,7 @@ public: Value *V = CI->getOperand(1); if (V->getType()->isSigned()) V = new CastInst(V, V->getType()->getUnsignedVersion(), V->getName(), CI); - Value *Cmp = BinaryOperator::createSetLT(V, ConstantUInt::get(V->getType(), + Value *Cmp = BinaryOperator::createSetLT(V, ConstantInt::get(V->getType(), 128), V->getName()+".isascii", CI); if (Cmp->getType() != CI->getType()) @@ -1828,7 +1828,7 @@ public: // ffs(cnst) -> bit# // ffsl(cnst) -> bit# // ffsll(cnst) -> bit# - uint64_t val = CI->getRawValue(); + uint64_t val = CI->getZExtValue(); int result = 0; if (val) { ++result; @@ -1837,7 +1837,7 @@ public: val >>= 1; } } - TheCall->replaceAllUsesWith(ConstantSInt::get(Type::IntTy, result)); + TheCall->replaceAllUsesWith(ConstantInt::get(Type::IntTy, result)); TheCall->eraseFromParent(); return true; } @@ -1861,7 +1861,7 @@ public: Value *V = new CastInst(TheCall->getOperand(1), ArgType, "tmp", TheCall); Value *V2 = new CallInst(F, V, "tmp", TheCall); V2 = new CastInst(V2, Type::IntTy, "tmp", TheCall); - V2 = BinaryOperator::createAdd(V2, ConstantSInt::get(Type::IntTy, 1), + V2 = BinaryOperator::createAdd(V2, ConstantInt::get(Type::IntTy, 1), "tmp", TheCall); Value *Cond = BinaryOperator::createSetEQ(V, Constant::getNullValue(V->getType()), @@ -2048,7 +2048,7 @@ bool getConstantStringLength(Value *V, uint64_t &len, ConstantArray **CA) { // value. We'll need this later for indexing the ConstantArray. uint64_t start_idx = 0; if (ConstantInt* CI = dyn_cast<ConstantInt>(GEP->getOperand(2))) - start_idx = CI->getRawValue(); + start_idx = CI->getZExtValue(); else return false; diff --git a/lib/Transforms/Instrumentation/EmitFunctions.cpp b/lib/Transforms/Instrumentation/EmitFunctions.cpp index 05c3419..b452325 100644 --- a/lib/Transforms/Instrumentation/EmitFunctions.cpp +++ b/lib/Transforms/Instrumentation/EmitFunctions.cpp @@ -110,7 +110,7 @@ bool EmitFunctionTable::runOnModule(Module &M){ M.getGlobalList().push_back(funcArray); - ConstantInt *cnst = ConstantSInt::get(Type::IntTy, counter); + ConstantInt *cnst = ConstantInt::get(Type::IntTy, counter); GlobalVariable *fnCount = new GlobalVariable(Type::IntTy, true, GlobalValue::ExternalLinkage, cnst, "llvmFunctionCount"); diff --git a/lib/Transforms/Instrumentation/ProfilingUtils.cpp b/lib/Transforms/Instrumentation/ProfilingUtils.cpp index 82e7ae7..4c31793 100644 --- a/lib/Transforms/Instrumentation/ProfilingUtils.cpp +++ b/lib/Transforms/Instrumentation/ProfilingUtils.cpp @@ -51,7 +51,7 @@ void llvm::InsertProfilingInitCall(Function *MainFn, const char *FnName, // pass null. Args[2] = ConstantPointerNull::get(UIntPtr); } - Args[3] = ConstantUInt::get(Type::UIntTy, NumElements); + Args[3] = ConstantInt::get(Type::UIntTy, NumElements); Instruction *InitCall = new CallInst(InitFn, Args, "newargc", InsertPos); @@ -96,7 +96,7 @@ void llvm::IncrementCounterInBlock(BasicBlock *BB, unsigned CounterNum, // Create the getelementptr constant expression std::vector<Constant*> Indices(2); Indices[0] = Constant::getNullValue(Type::IntTy); - Indices[1] = ConstantSInt::get(Type::IntTy, CounterNum); + Indices[1] = ConstantInt::get(Type::IntTy, CounterNum); Constant *ElementPtr = ConstantExpr::getGetElementPtr(CounterArray, Indices); // Load, increment and store the value back. diff --git a/lib/Transforms/Instrumentation/RSProfiling.cpp b/lib/Transforms/Instrumentation/RSProfiling.cpp index 54a9ef7..5d6654d 100644 --- a/lib/Transforms/Instrumentation/RSProfiling.cpp +++ b/lib/Transforms/Instrumentation/RSProfiling.cpp @@ -188,10 +188,10 @@ static void getBackEdges(Function& F, T& BackEdges); GlobalRandomCounter::GlobalRandomCounter(Module& M, const Type* t, uint64_t resetval) : T(t) { + ConstantInt* Init = ConstantInt::get(T, resetval); + ResetValue = Init; Counter = new GlobalVariable(T, false, GlobalValue::InternalLinkage, - ConstantUInt::get(T, resetval), - "RandomSteeringCounter", &M); - ResetValue = ConstantUInt::get(T, resetval); + Init, "RandomSteeringCounter", &M); } GlobalRandomCounter::~GlobalRandomCounter() {} @@ -205,7 +205,7 @@ void GlobalRandomCounter::ProcessChoicePoint(BasicBlock* bb) { LoadInst* l = new LoadInst(Counter, "counter", t); SetCondInst* s = new SetCondInst(Instruction::SetEQ, l, - ConstantUInt::get(T, 0), + ConstantInt::get(T, 0), "countercc", t); Value* nv = BinaryOperator::createSub(l, ConstantInt::get(T, 1), "counternew", t); @@ -225,10 +225,10 @@ void GlobalRandomCounter::ProcessChoicePoint(BasicBlock* bb) { GlobalRandomCounterOpt::GlobalRandomCounterOpt(Module& M, const Type* t, uint64_t resetval) : AI(0), T(t) { + ConstantInt* Init = ConstantInt::get(T, resetval); + ResetValue = Init; Counter = new GlobalVariable(T, false, GlobalValue::InternalLinkage, - ConstantUInt::get(T, resetval), - "RandomSteeringCounter", &M); - ResetValue = ConstantUInt::get(T, resetval); + Init, "RandomSteeringCounter", &M); } GlobalRandomCounterOpt::~GlobalRandomCounterOpt() {} @@ -278,7 +278,7 @@ void GlobalRandomCounterOpt::ProcessChoicePoint(BasicBlock* bb) { LoadInst* l = new LoadInst(AI, "counter", t); SetCondInst* s = new SetCondInst(Instruction::SetEQ, l, - ConstantUInt::get(T, 0), + ConstantInt::get(T, 0), "countercc", t); Value* nv = BinaryOperator::createSub(l, ConstantInt::get(T, 1), "counternew", t); @@ -309,11 +309,11 @@ void CycleCounter::ProcessChoicePoint(BasicBlock* bb) { CallInst* c = new CallInst(F, "rdcc", t); BinaryOperator* b = - BinaryOperator::createAnd(c, ConstantUInt::get(Type::ULongTy, rm), + BinaryOperator::createAnd(c, ConstantInt::get(Type::ULongTy, rm), "mrdcc", t); SetCondInst* s = new SetCondInst(Instruction::SetEQ, b, - ConstantUInt::get(Type::ULongTy, 0), + ConstantInt::get(Type::ULongTy, 0), "mrdccc", t); t->setCondition(s); } @@ -339,7 +339,7 @@ void RSProfilers_std::IncrementCounterInBlock(BasicBlock *BB, unsigned CounterNu // Create the getelementptr constant expression std::vector<Constant*> Indices(2); Indices[0] = Constant::getNullValue(Type::IntTy); - Indices[1] = ConstantSInt::get(Type::IntTy, CounterNum); + Indices[1] = ConstantInt::get(Type::IntTy, CounterNum); Constant *ElementPtr = ConstantExpr::getGetElementPtr(CounterArray, Indices); // Load, increment and store the value back. diff --git a/lib/Transforms/Instrumentation/TraceBasicBlocks.cpp b/lib/Transforms/Instrumentation/TraceBasicBlocks.cpp index d3af056..8bf6001 100644 --- a/lib/Transforms/Instrumentation/TraceBasicBlocks.cpp +++ b/lib/Transforms/Instrumentation/TraceBasicBlocks.cpp @@ -49,7 +49,7 @@ static void InsertInstrumentationCall (BasicBlock *BB, Function *InstrFn = M.getOrInsertFunction (FnName, Type::VoidTy, Type::UIntTy, (Type *)0); std::vector<Value*> Args (1); - Args[0] = ConstantUInt::get (Type::UIntTy, BBNumber); + Args[0] = ConstantInt::get (Type::UIntTy, BBNumber); // Insert the call after any alloca or PHI instructions... BasicBlock::iterator InsertPos = BB->begin(); diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp index 4a7edba..c30c0c9 100644 --- a/lib/Transforms/Scalar/InstructionCombining.cpp +++ b/lib/Transforms/Scalar/InstructionCombining.cpp @@ -142,7 +142,7 @@ namespace { Instruction *FoldGEPSetCC(User *GEPLHS, Value *RHS, Instruction::BinaryOps Cond, Instruction &I); Instruction *visitShiftInst(ShiftInst &I); - Instruction *FoldShiftByConstant(Value *Op0, ConstantUInt *Op1, + Instruction *FoldShiftByConstant(Value *Op0, ConstantInt *Op1, ShiftInst &I); Instruction *visitCastInst(CastInst &CI); Instruction *FoldSelectOpOp(SelectInst &SI, Instruction *TI, @@ -576,14 +576,14 @@ static ConstantInt *SubOne(ConstantInt *C) { /// GetConstantInType - Return a ConstantInt with the specified type and value. /// static ConstantIntegral *GetConstantInType(const Type *Ty, uint64_t Val) { - if (Ty->isUnsigned()) - return ConstantUInt::get(Ty, Val); + if (Ty->isUnsigned()) + return ConstantInt::get(Ty, Val); else if (Ty->getTypeID() == Type::BoolTyID) return ConstantBool::get(Val); int64_t SVal = Val; SVal <<= 64-Ty->getPrimitiveSizeInBits(); SVal >>= 64-Ty->getPrimitiveSizeInBits(); - return ConstantSInt::get(Ty, SVal); + return ConstantInt::get(Ty, SVal); } @@ -712,40 +712,42 @@ static void ComputeMaskedBits(Value *V, uint64_t Mask, uint64_t &KnownZero, } case Instruction::Shl: // (shl X, C1) & C2 == 0 iff (X & C2 >>u C1) == 0 - if (ConstantUInt *SA = dyn_cast<ConstantUInt>(I->getOperand(1))) { - Mask >>= SA->getValue(); + if (ConstantInt *SA = dyn_cast<ConstantInt>(I->getOperand(1))) { + uint64_t ShiftAmt = SA->getZExtValue(); + Mask >>= ShiftAmt; ComputeMaskedBits(I->getOperand(0), Mask, KnownZero, KnownOne, Depth+1); assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?"); - KnownZero <<= SA->getValue(); - KnownOne <<= SA->getValue(); - KnownZero |= (1ULL << SA->getValue())-1; // low bits known zero. + KnownZero <<= ShiftAmt; + KnownOne <<= ShiftAmt; + KnownZero |= (1ULL << ShiftAmt)-1; // low bits known zero. return; } break; case Instruction::Shr: // (ushr X, C1) & C2 == 0 iff (-1 >> C1) & C2 == 0 - if (ConstantUInt *SA = dyn_cast<ConstantUInt>(I->getOperand(1))) { + if (ConstantInt *SA = dyn_cast<ConstantInt>(I->getOperand(1))) { // Compute the new bits that are at the top now. - uint64_t HighBits = (1ULL << SA->getValue())-1; - HighBits <<= I->getType()->getPrimitiveSizeInBits()-SA->getValue(); + uint64_t ShiftAmt = SA->getZExtValue(); + uint64_t HighBits = (1ULL << ShiftAmt)-1; + HighBits <<= I->getType()->getPrimitiveSizeInBits()-ShiftAmt; if (I->getType()->isUnsigned()) { // Unsigned shift right. - Mask <<= SA->getValue(); + Mask <<= ShiftAmt; ComputeMaskedBits(I->getOperand(0), Mask, KnownZero,KnownOne,Depth+1); assert((KnownZero & KnownOne) == 0&&"Bits known to be one AND zero?"); - KnownZero >>= SA->getValue(); - KnownOne >>= SA->getValue(); + KnownZero >>= ShiftAmt; + KnownOne >>= ShiftAmt; KnownZero |= HighBits; // high bits known zero. } else { - Mask <<= SA->getValue(); + Mask <<= ShiftAmt; ComputeMaskedBits(I->getOperand(0), Mask, KnownZero,KnownOne,Depth+1); assert((KnownZero & KnownOne) == 0&&"Bits known to be one AND zero?"); - KnownZero >>= SA->getValue(); - KnownOne >>= SA->getValue(); + KnownZero >>= ShiftAmt; + KnownOne >>= ShiftAmt; // Handle the sign bits. uint64_t SignBit = 1ULL << (I->getType()->getPrimitiveSizeInBits()-1); - SignBit >>= SA->getValue(); // Adjust to where it is now in the mask. + SignBit >>= ShiftAmt; // Adjust to where it is now in the mask. if (KnownZero & SignBit) { // New bits are known zero. KnownZero |= HighBits; @@ -1100,14 +1102,15 @@ bool InstCombiner::SimplifyDemandedBits(Value *V, uint64_t DemandedMask, break; } case Instruction::Shl: - if (ConstantUInt *SA = dyn_cast<ConstantUInt>(I->getOperand(1))) { - if (SimplifyDemandedBits(I->getOperand(0), DemandedMask >> SA->getValue(), + if (ConstantInt *SA = dyn_cast<ConstantInt>(I->getOperand(1))) { + uint64_t ShiftAmt = SA->getZExtValue(); + if (SimplifyDemandedBits(I->getOperand(0), DemandedMask >> ShiftAmt, KnownZero, KnownOne, Depth+1)) return true; assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?"); - KnownZero <<= SA->getValue(); - KnownOne <<= SA->getValue(); - KnownZero |= (1ULL << SA->getValue())-1; // low bits known zero. + KnownZero <<= ShiftAmt; + KnownOne <<= ShiftAmt; + KnownZero |= (1ULL << ShiftAmt) - 1; // low bits known zero. } break; case Instruction::Shr: @@ -1131,38 +1134,38 @@ bool InstCombiner::SimplifyDemandedBits(Value *V, uint64_t DemandedMask, return UpdateValueUsesWith(I, NewVal); } - if (ConstantUInt *SA = dyn_cast<ConstantUInt>(I->getOperand(1))) { - unsigned ShAmt = SA->getValue(); + if (ConstantInt *SA = dyn_cast<ConstantInt>(I->getOperand(1))) { + unsigned ShiftAmt = SA->getZExtValue(); // Compute the new bits that are at the top now. - uint64_t HighBits = (1ULL << ShAmt)-1; - HighBits <<= I->getType()->getPrimitiveSizeInBits() - ShAmt; + uint64_t HighBits = (1ULL << ShiftAmt)-1; + HighBits <<= I->getType()->getPrimitiveSizeInBits() - ShiftAmt; uint64_t TypeMask = I->getType()->getIntegralTypeMask(); if (I->getType()->isUnsigned()) { // Unsigned shift right. if (SimplifyDemandedBits(I->getOperand(0), - (DemandedMask << ShAmt) & TypeMask, + (DemandedMask << ShiftAmt) & TypeMask, KnownZero, KnownOne, Depth+1)) return true; assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?"); KnownZero &= TypeMask; KnownOne &= TypeMask; - KnownZero >>= ShAmt; - KnownOne >>= ShAmt; + KnownZero >>= ShiftAmt; + KnownOne >>= ShiftAmt; KnownZero |= HighBits; // high bits known zero. } else { // Signed shift right. if (SimplifyDemandedBits(I->getOperand(0), - (DemandedMask << ShAmt) & TypeMask, + (DemandedMask << ShiftAmt) & TypeMask, KnownZero, KnownOne, Depth+1)) return true; assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?"); KnownZero &= TypeMask; KnownOne &= TypeMask; - KnownZero >>= SA->getValue(); - KnownOne >>= SA->getValue(); + KnownZero >>= ShiftAmt; + KnownOne >>= ShiftAmt; // Handle the sign bits. uint64_t SignBit = 1ULL << (I->getType()->getPrimitiveSizeInBits()-1); - SignBit >>= SA->getValue(); // Adjust to where it is now in the mask. + SignBit >>= ShiftAmt; // Adjust to where it is now in the mask. // If the input sign bit is known to be zero, or if none of the top bits // are demanded, turn this into an unsigned shift right. @@ -1277,7 +1280,7 @@ Value *InstCombiner::SimplifyDemandedVectorElts(Value *V, uint64_t DemandedElts, case Instruction::InsertElement: { // If this is a variable index, we don't know which element it overwrites. // demand exactly the same input as we produce. - ConstantUInt *Idx = dyn_cast<ConstantUInt>(I->getOperand(2)); + ConstantInt *Idx = dyn_cast<ConstantInt>(I->getOperand(2)); if (Idx == 0) { // Note that we can't propagate undef elt info, because we don't know // which elt is getting updated. @@ -1289,7 +1292,7 @@ Value *InstCombiner::SimplifyDemandedVectorElts(Value *V, uint64_t DemandedElts, // If this is inserting an element that isn't demanded, remove this // insertelement. - unsigned IdxNo = Idx->getValue(); + unsigned IdxNo = Idx->getZExtValue(); if (IdxNo >= VWidth || (DemandedElts & (1ULL << IdxNo)) == 0) return AddSoonDeadInstToWorklist(*I, 0); @@ -1795,14 +1798,14 @@ FoundSExt: if (Anded == CRHS) { // See if all bits from the first bit set in the Add RHS up are included // in the mask. First, get the rightmost bit. - uint64_t AddRHSV = CRHS->getRawValue(); + uint64_t AddRHSV = CRHS->getZExtValue(); // Form a mask of all bits from the lowest bit added through the top. uint64_t AddRHSHighBits = ~((AddRHSV & -AddRHSV)-1); AddRHSHighBits &= C2->getType()->getIntegralTypeMask(); // See if the and mask includes all of these bits. - uint64_t AddRHSHighBitsAnd = AddRHSHighBits & C2->getRawValue(); + uint64_t AddRHSHighBitsAnd = AddRHSHighBits & C2->getZExtValue(); if (AddRHSHighBits == AddRHSHighBitsAnd) { // Okay, the xform is safe. Insert the new add pronto. @@ -1845,7 +1848,7 @@ FoundSExt: // highest order bit set. static bool isSignBit(ConstantInt *CI) { unsigned NumBits = CI->getType()->getPrimitiveSizeInBits(); - return (CI->getRawValue() & (~0ULL >> (64-NumBits))) == (1ULL << (NumBits-1)); + return (CI->getZExtValue() & (~0ULL >> (64-NumBits))) == (1ULL << (NumBits-1)); } /// RemoveNoopCast - Strip off nonconverting casts from the value. @@ -1894,14 +1897,15 @@ Instruction *InstCombiner::visitSub(BinaryOperator &I) { Value *NoopCastedRHS = RemoveNoopCast(Op1); if (ShiftInst *SI = dyn_cast<ShiftInst>(NoopCastedRHS)) if (SI->getOpcode() == Instruction::Shr) - if (ConstantUInt *CU = dyn_cast<ConstantUInt>(SI->getOperand(1))) { + if (ConstantInt *CU = dyn_cast<ConstantInt>(SI->getOperand(1))) { const Type *NewTy; if (SI->getType()->isSigned()) NewTy = SI->getType()->getUnsignedVersion(); else NewTy = SI->getType()->getSignedVersion(); // Check to see if we are shifting out everything but the sign bit. - if (CU->getValue() == SI->getType()->getPrimitiveSizeInBits()-1) { + if (CU->getZExtValue() == + SI->getType()->getPrimitiveSizeInBits()-1) { // Ok, the transformation is safe. Insert a cast of the incoming // value, then the new shift, then the new cast. Instruction *FirstCast = new CastInst(SI->getOperand(0), NewTy, @@ -1972,8 +1976,8 @@ Instruction *InstCombiner::visitSub(BinaryOperator &I) { // 0 - (X sdiv C) -> (X sdiv -C) if (Op1I->getOpcode() == Instruction::Div) - if (ConstantSInt *CSI = dyn_cast<ConstantSInt>(Op0)) - if (CSI->isNullValue()) + if (ConstantInt *CSI = dyn_cast<ConstantInt>(Op0)) + if (CSI->getType()->isSigned() && CSI->isNullValue()) if (Constant *DivRHS = dyn_cast<Constant>(Op1I->getOperand(1))) return BinaryOperator::createDiv(Op1I->getOperand(0), ConstantExpr::getNeg(DivRHS)); @@ -2022,14 +2026,14 @@ static bool isSignBitCheck(unsigned Opcode, Value *LHS, ConstantInt *RHS) { return Opcode == Instruction::SetLT && RHS->isNullValue() || Opcode == Instruction::SetLE && RHS->isAllOnesValue(); } else { - ConstantUInt *RHSC = cast<ConstantUInt>(RHS); + ConstantInt *RHSC = cast<ConstantInt>(RHS); // True if source is LHS > 127 or LHS >= 128, where the constants depend on // the size of the integer type. if (Opcode == Instruction::SetGE) - return RHSC->getValue() == + return RHSC->getZExtValue() == 1ULL << (RHS->getType()->getPrimitiveSizeInBits()-1); if (Opcode == Instruction::SetGT) - return RHSC->getValue() == + return RHSC->getZExtValue() == (1ULL << (RHS->getType()->getPrimitiveSizeInBits()-1))-1; } return false; @@ -2060,11 +2064,11 @@ Instruction *InstCombiner::visitMul(BinaryOperator &I) { if (CI->isAllOnesValue()) // X * -1 == 0 - X return BinaryOperator::createNeg(Op0, I.getName()); - int64_t Val = (int64_t)cast<ConstantInt>(CI)->getRawValue(); + int64_t Val = (int64_t)cast<ConstantInt>(CI)->getZExtValue(); if (isPowerOf2_64(Val)) { // Replace X*(2^C) with X << C uint64_t C = Log2_64(Val); return new ShiftInst(Instruction::Shl, Op0, - ConstantUInt::get(Type::UByteTy, C)); + ConstantInt::get(Type::UByteTy, C)); } } else if (ConstantFP *Op1F = dyn_cast<ConstantFP>(Op1)) { if (Op1F->isNullValue()) @@ -2125,7 +2129,7 @@ Instruction *InstCombiner::visitMul(BinaryOperator &I) { if (isa<ConstantInt>(SCIOp1) && isSignBitCheck(SCI->getOpcode(), SCIOp0, cast<ConstantInt>(SCIOp1))) { // Shift the X value right to turn it into "all signbits". - Constant *Amt = ConstantUInt::get(Type::UByteTy, + Constant *Amt = ConstantInt::get(Type::UByteTy, SCOpTy->getPrimitiveSizeInBits()-1); if (SCIOp0->getType()->isUnsigned()) { const Type *NewTy = SCIOp0->getType()->getSignedVersion(); @@ -2179,13 +2183,14 @@ Instruction *InstCombiner::visitDiv(BinaryOperator &I) { // Check to see if this is an unsigned division with an exact power of 2, // if so, convert to a right shift. - if (ConstantUInt *C = dyn_cast<ConstantUInt>(RHS)) - if (uint64_t Val = C->getValue()) // Don't break X / 0 - if (isPowerOf2_64(Val)) { - uint64_t C = Log2_64(Val); - return new ShiftInst(Instruction::Shr, Op0, - ConstantUInt::get(Type::UByteTy, C)); - } + if (ConstantInt *C = dyn_cast<ConstantInt>(RHS)) + if (C->getType()->isUnsigned()) + if (uint64_t Val = C->getZExtValue()) // Don't break X / 0 + if (isPowerOf2_64(Val)) { + uint64_t C = Log2_64(Val); + return new ShiftInst(Instruction::Shr, Op0, + ConstantInt::get(Type::UByteTy, C)); + } // -X/C -> X/-C if (RHS->getType()->isSigned()) @@ -2235,24 +2240,25 @@ Instruction *InstCombiner::visitDiv(BinaryOperator &I) { // If this is 'udiv X, (Cond ? C1, C2)' where C1&C2 are powers of two, // transform this into: '(Cond ? (udiv X, C1) : (udiv X, C2))'. - if (ConstantUInt *STO = dyn_cast<ConstantUInt>(SI->getOperand(1))) - if (ConstantUInt *SFO = dyn_cast<ConstantUInt>(SI->getOperand(2))) { - // STO == 0 and SFO == 0 handled above. - uint64_t TVA = STO->getValue(), FVA = SFO->getValue(); - if (isPowerOf2_64(TVA) && isPowerOf2_64(FVA)) { - unsigned TSA = Log2_64(TVA), FSA = Log2_64(FVA); - Constant *TC = ConstantUInt::get(Type::UByteTy, TSA); - Instruction *TSI = new ShiftInst(Instruction::Shr, Op0, - TC, SI->getName()+".t"); - TSI = InsertNewInstBefore(TSI, I); - - Constant *FC = ConstantUInt::get(Type::UByteTy, FSA); - Instruction *FSI = new ShiftInst(Instruction::Shr, Op0, - FC, SI->getName()+".f"); - FSI = InsertNewInstBefore(FSI, I); - return new SelectInst(SI->getOperand(0), TSI, FSI); + if (ConstantInt *STO = dyn_cast<ConstantInt>(SI->getOperand(1))) + if (ConstantInt *SFO = dyn_cast<ConstantInt>(SI->getOperand(2))) + if (STO->getType()->isUnsigned() && SFO->getType()->isUnsigned()) { + // STO == 0 and SFO == 0 handled above. + uint64_t TVA = STO->getZExtValue(), FVA = SFO->getZExtValue(); + if (isPowerOf2_64(TVA) && isPowerOf2_64(FVA)) { + unsigned TSA = Log2_64(TVA), FSA = Log2_64(FVA); + Constant *TC = ConstantInt::get(Type::UByteTy, TSA); + Instruction *TSI = new ShiftInst(Instruction::Shr, Op0, + TC, SI->getName()+".t"); + TSI = InsertNewInstBefore(TSI, I); + + Constant *FC = ConstantInt::get(Type::UByteTy, FSA); + Instruction *FSI = new ShiftInst(Instruction::Shr, Op0, + FC, SI->getName()+".f"); + FSI = InsertNewInstBefore(FSI, I); + return new SelectInst(SI->getOperand(0), TSI, FSI); + } } - } } // 0 / X == 0, we don't need to preserve faults! @@ -2282,13 +2288,14 @@ Instruction *InstCombiner::visitDiv(BinaryOperator &I) { if (Instruction *RHSI = dyn_cast<Instruction>(I.getOperand(1))) { // Turn A / (C1 << N), where C1 is "1<<C2" into A >> (N+C2) [udiv only]. if (RHSI->getOpcode() == Instruction::Shl && - isa<ConstantUInt>(RHSI->getOperand(0))) { - unsigned C1 = cast<ConstantUInt>(RHSI->getOperand(0))->getRawValue(); + isa<ConstantInt>(RHSI->getOperand(0)) && + RHSI->getOperand(0)->getType()->isUnsigned()) { + uint64_t C1 = cast<ConstantInt>(RHSI->getOperand(0))->getZExtValue(); if (isPowerOf2_64(C1)) { - unsigned C2 = Log2_64(C1); + uint64_t C2 = Log2_64(C1); Value *Add = RHSI->getOperand(1); if (C2) { - Constant *C2V = ConstantUInt::get(Add->getType(), C2); + Constant *C2V = ConstantInt::get(Add->getType(), C2); Add = InsertNewInstBefore(BinaryOperator::createAdd(Add, C2V, "tmp"), I); } @@ -2330,7 +2337,7 @@ static Constant *GetFactor(Value *V) { unsigned Zeros = CountTrailingZeros_64(RHS->getZExtValue()); if (Zeros != V->getType()->getPrimitiveSizeInBits()) return ConstantExpr::getShl(Result, - ConstantUInt::get(Type::UByteTy, Zeros)); + ConstantInt::get(Type::UByteTy, Zeros)); } } else if (I->getOpcode() == Instruction::Cast) { Value *Op = I->getOperand(0); @@ -2356,8 +2363,8 @@ Instruction *InstCombiner::visitRem(BinaryOperator &I) { if (I.getType()->isSigned()) { if (Value *RHSNeg = dyn_castNegVal(Op1)) - if (!isa<ConstantSInt>(RHSNeg) || - cast<ConstantSInt>(RHSNeg)->getValue() > 0) { + if (!isa<ConstantInt>(RHSNeg) || !RHSNeg->getType()->isSigned() || + cast<ConstantInt>(RHSNeg)->getSExtValue() > 0) { // X % -Y -> X % Y AddUsesToWorkList(I); I.setOperand(1, RHSNeg); @@ -2392,9 +2399,10 @@ Instruction *InstCombiner::visitRem(BinaryOperator &I) { // Check to see if this is an unsigned remainder with an exact power of 2, // if so, convert to a bitwise and. - if (ConstantUInt *C = dyn_cast<ConstantUInt>(RHS)) - if (isPowerOf2_64(C->getValue())) - return BinaryOperator::createAnd(Op0, SubOne(C)); + if (ConstantInt *C = dyn_cast<ConstantInt>(RHS)) + if (RHS->getType()->isUnsigned()) + if (isPowerOf2_64(C->getZExtValue())) + return BinaryOperator::createAnd(Op0, SubOne(C)); if (Instruction *Op0I = dyn_cast<Instruction>(Op0)) { if (SelectInst *SI = dyn_cast<SelectInst>(Op0I)) { @@ -2415,8 +2423,9 @@ Instruction *InstCombiner::visitRem(BinaryOperator &I) { // Turn A % (C << N), where C is 2^k, into A & ((C << N)-1) [urem only]. if (I.getType()->isUnsigned() && RHSI->getOpcode() == Instruction::Shl && - isa<ConstantUInt>(RHSI->getOperand(0))) { - unsigned C1 = cast<ConstantUInt>(RHSI->getOperand(0))->getRawValue(); + isa<ConstantInt>(RHSI->getOperand(0)) && + RHSI->getOperand(0)->getType()->isUnsigned()) { + unsigned C1 = cast<ConstantInt>(RHSI->getOperand(0))->getZExtValue(); if (isPowerOf2_64(C1)) { Constant *N1 = ConstantInt::getAllOnesValue(I.getType()); Value *Add = InsertNewInstBefore(BinaryOperator::createAdd(RHSI, N1, @@ -2458,18 +2467,21 @@ Instruction *InstCombiner::visitRem(BinaryOperator &I) { } - if (ConstantUInt *STO = dyn_cast<ConstantUInt>(SI->getOperand(1))) - if (ConstantUInt *SFO = dyn_cast<ConstantUInt>(SI->getOperand(2))) { - // STO == 0 and SFO == 0 handled above. - - if (isPowerOf2_64(STO->getValue()) && isPowerOf2_64(SFO->getValue())){ - Value *TrueAnd = InsertNewInstBefore(BinaryOperator::createAnd(Op0, - SubOne(STO), SI->getName()+".t"), I); - Value *FalseAnd = InsertNewInstBefore(BinaryOperator::createAnd(Op0, - SubOne(SFO), SI->getName()+".f"), I); - return new SelectInst(SI->getOperand(0), TrueAnd, FalseAnd); + if (ConstantInt *STO = dyn_cast<ConstantInt>(SI->getOperand(1))) + if (ConstantInt *SFO = dyn_cast<ConstantInt>(SI->getOperand(2))) + if (STO->getType()->isUnsigned() && SFO->getType()->isUnsigned()) { + // STO == 0 and SFO == 0 handled above. + if (isPowerOf2_64(STO->getZExtValue()) && + isPowerOf2_64(SFO->getZExtValue())) { + Value *TrueAnd = InsertNewInstBefore( + BinaryOperator::createAnd(Op0, SubOne(STO), SI->getName()+".t"), + I); + Value *FalseAnd = InsertNewInstBefore( + BinaryOperator::createAnd(Op0, SubOne(SFO), SI->getName()+".f"), + I); + return new SelectInst(SI->getOperand(0), TrueAnd, FalseAnd); + } } - } } } @@ -2478,46 +2490,42 @@ Instruction *InstCombiner::visitRem(BinaryOperator &I) { // isMaxValueMinusOne - return true if this is Max-1 static bool isMaxValueMinusOne(const ConstantInt *C) { - if (const ConstantUInt *CU = dyn_cast<ConstantUInt>(C)) - return CU->getValue() == C->getType()->getIntegralTypeMask()-1; - - const ConstantSInt *CS = cast<ConstantSInt>(C); + if (C->getType()->isUnsigned()) + return C->getZExtValue() == C->getType()->getIntegralTypeMask()-1; // Calculate 0111111111..11111 unsigned TypeBits = C->getType()->getPrimitiveSizeInBits(); int64_t Val = INT64_MAX; // All ones Val >>= 64-TypeBits; // Shift out unwanted 1 bits... - return CS->getValue() == Val-1; + return C->getSExtValue() == Val-1; } // isMinValuePlusOne - return true if this is Min+1 static bool isMinValuePlusOne(const ConstantInt *C) { - if (const ConstantUInt *CU = dyn_cast<ConstantUInt>(C)) - return CU->getValue() == 1; - - const ConstantSInt *CS = cast<ConstantSInt>(C); + if (C->getType()->isUnsigned()) + return C->getZExtValue() == 1; // Calculate 1111111111000000000000 unsigned TypeBits = C->getType()->getPrimitiveSizeInBits(); int64_t Val = -1; // All ones Val <<= TypeBits-1; // Shift over to the right spot - return CS->getValue() == Val+1; + return C->getSExtValue() == Val+1; } // isOneBitSet - Return true if there is exactly one bit set in the specified // constant. static bool isOneBitSet(const ConstantInt *CI) { - uint64_t V = CI->getRawValue(); + uint64_t V = CI->getZExtValue(); return V && (V & (V-1)) == 0; } #if 0 // Currently unused // isLowOnes - Return true if the constant is of the form 0+1+. static bool isLowOnes(const ConstantInt *CI) { - uint64_t V = CI->getRawValue(); + uint64_t V = CI->getZExtValue(); // There won't be bits set in parts that the type doesn't contain. - V &= ConstantInt::getAllOnesValue(CI->getType())->getRawValue(); + V &= ConstantInt::getAllOnesValue(CI->getType())->getZExtValue(); uint64_t U = V+1; // If it is low ones, this should be a power of two. return U && V && (U & V) == 0; @@ -2527,11 +2535,11 @@ static bool isLowOnes(const ConstantInt *CI) { // isHighOnes - Return true if the constant is of the form 1+0+. // This is the same as lowones(~X). static bool isHighOnes(const ConstantInt *CI) { - uint64_t V = ~CI->getRawValue(); + uint64_t V = ~CI->getZExtValue(); if (~V == 0) return false; // 0's does not match "1+" // There won't be bits set in parts that the type doesn't contain. - V &= ConstantInt::getAllOnesValue(CI->getType())->getRawValue(); + V &= ConstantInt::getAllOnesValue(CI->getType())->getZExtValue(); uint64_t U = V+1; // If it is low ones, this should be a power of two. return U && V && (U & V) == 0; @@ -2656,7 +2664,7 @@ Instruction *InstCombiner::OptAndOp(Instruction *Op, // Adding a one to a single bit bit-field should be turned into an XOR // of the bit. First thing to check is to see if this AND is with a // single bit constant. - uint64_t AndRHSV = cast<ConstantInt>(AndRHS)->getRawValue(); + uint64_t AndRHSV = cast<ConstantInt>(AndRHS)->getZExtValue(); // Clear bits that are not part of the constant. AndRHSV &= AndRHS->getType()->getIntegralTypeMask(); @@ -2666,7 +2674,7 @@ Instruction *InstCombiner::OptAndOp(Instruction *Op, // Ok, at this point, we know that we are masking the result of the // ADD down to exactly one bit. If the constant we are adding has // no bits set below this bit, then we can eliminate the ADD. - uint64_t AddRHS = cast<ConstantInt>(OpRHS)->getRawValue(); + uint64_t AddRHS = cast<ConstantInt>(OpRHS)->getZExtValue(); // Check to see if any bits below the one bit set in AndRHSV are set. if ((AddRHS & (AndRHSV-1)) == 0) { @@ -2780,7 +2788,9 @@ Instruction *InstCombiner::InsertRangeTest(Value *V, Constant *Lo, Constant *Hi, return new SetCondInst(Instruction::SetEQ, V, V); Hi = SubOne(cast<ConstantInt>(Hi)); - if (cast<ConstantIntegral>(Lo)->isMinValue()) // V < 0 || V >= Hi ->'V > Hi-1' + + // V < 0 || V >= Hi ->'V > Hi-1' + if (cast<ConstantIntegral>(Lo)->isMinValue()) return new SetCondInst(Instruction::SetGT, V, Hi); // Emit X-Lo > Hi-Lo-1 @@ -2800,7 +2810,7 @@ Instruction *InstCombiner::InsertRangeTest(Value *V, Constant *Lo, Constant *Hi, // MSB, so 0x000FFF0, 0x0000FFFF, and 0xFF0000FF are all runs. 0x0F0F0000 is // not, since all 1s are not contiguous. static bool isRunOfOnes(ConstantIntegral *Val, unsigned &MB, unsigned &ME) { - uint64_t V = Val->getRawValue(); + uint64_t V = Val->getZExtValue(); if (!isShiftedMask_64(V)) return false; // look for the first zero bit after the run of ones @@ -2836,7 +2846,7 @@ Value *InstCombiner::FoldLogicalPlusAnd(Value *LHS, Value *RHS, case Instruction::And: if (ConstantExpr::getAnd(N, Mask) == Mask) { // If the AndRHS is a power of two minus one (0+1+), this is simple. - if ((Mask->getRawValue() & Mask->getRawValue()+1) == 0) + if ((Mask->getZExtValue() & Mask->getZExtValue()+1) == 0) break; // Otherwise, if Mask is 0+1+0+, and if B is known to have the low 0+ @@ -2854,7 +2864,7 @@ Value *InstCombiner::FoldLogicalPlusAnd(Value *LHS, Value *RHS, case Instruction::Or: case Instruction::Xor: // If the AndRHS is a power of two minus one (0+1+), and N&Mask == 0 - if ((Mask->getRawValue() & Mask->getRawValue()+1) == 0 && + if ((Mask->getZExtValue() & Mask->getZExtValue()+1) == 0 && ConstantExpr::getAnd(N, Mask)->isNullValue()) break; return 0; @@ -3168,7 +3178,7 @@ static bool CollectBSwapParts(Value *V, std::vector<Value*> &ByteValues) { // defines a byte. We only handle unsigned types here. if (isa<ShiftInst>(I) && isa<ConstantInt>(I->getOperand(1))) { // Not shifting the entire input by N-1 bytes? - if (cast<ConstantInt>(I->getOperand(1))->getRawValue() != + if (cast<ConstantInt>(I->getOperand(1))->getZExtValue() != 8*(ByteValues.size()-1)) return true; @@ -3199,19 +3209,19 @@ static bool CollectBSwapParts(Value *V, std::vector<Value*> &ByteValues) { Instruction *SI = cast<Instruction>(Shift); // Make sure that the shift amount is by a multiple of 8 and isn't too big. - if (ShiftAmt->getRawValue() & 7 || - ShiftAmt->getRawValue() > 8*ByteValues.size()) + if (ShiftAmt->getZExtValue() & 7 || + ShiftAmt->getZExtValue() > 8*ByteValues.size()) return true; // Turn 0xFF -> 0, 0xFF00 -> 1, 0xFF0000 -> 2, etc. unsigned DestByte; for (DestByte = 0; DestByte != ByteValues.size(); ++DestByte) - if (AndAmt->getRawValue() == uint64_t(0xFF) << 8*DestByte) + if (AndAmt->getZExtValue() == uint64_t(0xFF) << 8*DestByte) break; // Unknown mask for bswap. if (DestByte == ByteValues.size()) return true; - unsigned ShiftBytes = ShiftAmt->getRawValue()/8; + unsigned ShiftBytes = ShiftAmt->getZExtValue()/8; unsigned SrcByte; if (SI->getOpcode() == Instruction::Shl) SrcByte = DestByte - ShiftBytes; @@ -3372,7 +3382,7 @@ Instruction *InstCombiner::visitOr(BinaryOperator &I) { // replace with V+N. if (C1 == ConstantExpr::getNot(C2)) { Value *V1 = 0, *V2 = 0; - if ((C2->getRawValue() & (C2->getRawValue()+1)) == 0 && // C2 == 0+1+ + if ((C2->getZExtValue() & (C2->getZExtValue()+1)) == 0 && // C2 == 0+1+ match(A, m_Add(m_Value(V1), m_Value(V2)))) { // Add commutes, try both ways. if (V1 == B && MaskedValueIsZero(V2, C2->getZExtValue())) @@ -3381,7 +3391,7 @@ Instruction *InstCombiner::visitOr(BinaryOperator &I) { return ReplaceInstUsesWith(I, A); } // Or commutes, try both ways. - if ((C1->getRawValue() & (C1->getRawValue()+1)) == 0 && + if ((C1->getZExtValue() & (C1->getZExtValue()+1)) == 0 && match(B, m_Add(m_Value(V1), m_Value(V2)))) { // Add commutes, try both ways. if (V1 == A && MaskedValueIsZero(V2, C1->getZExtValue())) @@ -3716,7 +3726,7 @@ static bool MulWithOverflow(ConstantInt *&Result, ConstantInt *In1, } static bool isPositive(ConstantInt *C) { - return cast<ConstantSInt>(C)->getValue() >= 0; + return C->getSExtValue() >= 0; } /// AddWithOverflow - Compute Result = In1+In2, returning true if the result @@ -3726,15 +3736,15 @@ static bool AddWithOverflow(ConstantInt *&Result, ConstantInt *In1, Result = cast<ConstantInt>(ConstantExpr::getAdd(In1, In2)); if (In1->getType()->isUnsigned()) - return cast<ConstantUInt>(Result)->getValue() < - cast<ConstantUInt>(In1)->getValue(); + return cast<ConstantInt>(Result)->getZExtValue() < + cast<ConstantInt>(In1)->getZExtValue(); if (isPositive(In1) != isPositive(In2)) return false; if (isPositive(In1)) - return cast<ConstantSInt>(Result)->getValue() < - cast<ConstantSInt>(In1)->getValue(); - return cast<ConstantSInt>(Result)->getValue() > - cast<ConstantSInt>(In1)->getValue(); + return cast<ConstantInt>(Result)->getSExtValue() < + cast<ConstantInt>(In1)->getSExtValue(); + return cast<ConstantInt>(Result)->getSExtValue() > + cast<ConstantInt>(In1)->getSExtValue(); } /// EmitGEPOffset - Given a getelementptr instruction/constantexpr, emit the @@ -3753,7 +3763,7 @@ static Value *EmitGEPOffset(User *GEP, Instruction &I, InstCombiner &IC) { for (unsigned i = 1, e = GEP->getNumOperands(); i != e; ++i, ++GTI) { Value *Op = GEP->getOperand(i); uint64_t Size = TD.getTypeSize(GTI.getIndexedType()) & PtrSizeMask; - Constant *Scale = ConstantExpr::getCast(ConstantUInt::get(UIntPtrTy, Size), + Constant *Scale = ConstantExpr::getCast(ConstantInt::get(UIntPtrTy, Size), SIntPtrTy); if (Constant *OpC = dyn_cast<Constant>(Op)) { if (!OpC->isNullValue()) { @@ -4139,14 +4149,14 @@ Instruction *InstCombiner::visitSetCondInst(SetCondInst &I) { ConstantInt *NewCST; ConstantInt *NewCI; if (Cast->getOperand(0)->getType()->isSigned()) { - NewCST = ConstantSInt::get(Cast->getOperand(0)->getType(), + NewCST = ConstantInt::get(Cast->getOperand(0)->getType(), AndCST->getZExtValue()); - NewCI = ConstantSInt::get(Cast->getOperand(0)->getType(), + NewCI = ConstantInt::get(Cast->getOperand(0)->getType(), CI->getZExtValue()); } else { - NewCST = ConstantUInt::get(Cast->getOperand(0)->getType(), + NewCST = ConstantInt::get(Cast->getOperand(0)->getType(), AndCST->getZExtValue()); - NewCI = ConstantUInt::get(Cast->getOperand(0)->getType(), + NewCI = ConstantInt::get(Cast->getOperand(0)->getType(), CI->getZExtValue()); } Instruction *NewAnd = @@ -4172,8 +4182,8 @@ Instruction *InstCombiner::visitSetCondInst(SetCondInst &I) { Shift = dyn_cast<ShiftInst>(CI->getOperand(0)); } - ConstantUInt *ShAmt; - ShAmt = Shift ? dyn_cast<ConstantUInt>(Shift->getOperand(1)) : 0; + ConstantInt *ShAmt; + ShAmt = Shift ? dyn_cast<ConstantInt>(Shift->getOperand(1)) : 0; const Type *Ty = Shift ? Shift->getType() : 0; // Type of the shift. const Type *AndTy = AndCST->getType(); // Type of the and. @@ -4185,10 +4195,10 @@ Instruction *InstCombiner::visitSetCondInst(SetCondInst &I) { if (!CanFold) { // To test for the bad case of the signed shr, see if any // of the bits shifted in could be tested after the mask. - int ShAmtVal = Ty->getPrimitiveSizeInBits()-ShAmt->getValue(); + int ShAmtVal = Ty->getPrimitiveSizeInBits()-ShAmt->getZExtValue(); if (ShAmtVal < 0) ShAmtVal = 0; // Out of range shift. - Constant *OShAmt = ConstantUInt::get(Type::UByteTy, ShAmtVal); + Constant *OShAmt = ConstantInt::get(Type::UByteTy, ShAmtVal); Constant *ShVal = ConstantExpr::getShl(ConstantInt::getAllOnesValue(AndTy), OShAmt); @@ -4277,14 +4287,14 @@ Instruction *InstCombiner::visitSetCondInst(SetCondInst &I) { break; case Instruction::Shl: // (setcc (shl X, ShAmt), CI) - if (ConstantUInt *ShAmt = dyn_cast<ConstantUInt>(LHSI->getOperand(1))) { + if (ConstantInt *ShAmt = dyn_cast<ConstantInt>(LHSI->getOperand(1))) { if (I.isEquality()) { unsigned TypeBits = CI->getType()->getPrimitiveSizeInBits(); // Check that the shift amount is in range. If not, don't perform // undefined shifts. When the shift is visited it will be // simplified. - if (ShAmt->getValue() >= TypeBits) + if (ShAmt->getZExtValue() >= TypeBits) break; // If we are comparing against bits always shifted out, the @@ -4299,14 +4309,14 @@ Instruction *InstCombiner::visitSetCondInst(SetCondInst &I) { if (LHSI->hasOneUse()) { // Otherwise strength reduce the shift into an and. - unsigned ShAmtVal = (unsigned)ShAmt->getValue(); + unsigned ShAmtVal = (unsigned)ShAmt->getZExtValue(); uint64_t Val = (1ULL << (TypeBits-ShAmtVal))-1; Constant *Mask; if (CI->getType()->isUnsigned()) { - Mask = ConstantUInt::get(CI->getType(), Val); + Mask = ConstantInt::get(CI->getType(), Val); } else if (ShAmtVal != 0) { - Mask = ConstantSInt::get(CI->getType(), Val); + Mask = ConstantInt::get(CI->getType(), Val); } else { Mask = ConstantInt::getAllOnesValue(CI->getType()); } @@ -4323,13 +4333,13 @@ Instruction *InstCombiner::visitSetCondInst(SetCondInst &I) { break; case Instruction::Shr: // (setcc (shr X, ShAmt), CI) - if (ConstantUInt *ShAmt = dyn_cast<ConstantUInt>(LHSI->getOperand(1))) { + if (ConstantInt *ShAmt = dyn_cast<ConstantInt>(LHSI->getOperand(1))) { if (I.isEquality()) { // Check that the shift amount is in range. If not, don't perform // undefined shifts. When the shift is visited it will be // simplified. unsigned TypeBits = CI->getType()->getPrimitiveSizeInBits(); - if (ShAmt->getValue() >= TypeBits) + if (ShAmt->getZExtValue() >= TypeBits) break; // If we are comparing against bits always shifted out, the @@ -4344,7 +4354,7 @@ Instruction *InstCombiner::visitSetCondInst(SetCondInst &I) { } if (LHSI->hasOneUse() || CI->isNullValue()) { - unsigned ShAmtVal = (unsigned)ShAmt->getValue(); + unsigned ShAmtVal = (unsigned)ShAmt->getZExtValue(); // Otherwise strength reduce the shift into an and. uint64_t Val = ~0ULL; // All ones. @@ -4353,9 +4363,9 @@ Instruction *InstCombiner::visitSetCondInst(SetCondInst &I) { Constant *Mask; if (CI->getType()->isUnsigned()) { Val &= ~0ULL >> (64-TypeBits); - Mask = ConstantUInt::get(CI->getType(), Val); + Mask = ConstantInt::get(CI->getType(), Val); } else { - Mask = ConstantSInt::get(CI->getType(), Val); + Mask = ConstantInt::get(CI->getType(), Val); } Instruction *AndI = @@ -4466,22 +4476,40 @@ Instruction *InstCombiner::visitSetCondInst(SetCondInst &I) { if (I.isEquality()) { bool isSetNE = I.getOpcode() == Instruction::SetNE; - // If the first operand is (and|or|xor) with a constant, and the second - // operand is a constant, simplify a bit. + // If the first operand is (add|sub|and|or|xor|rem) with a constant, and + // the second operand is a constant, simplify a bit. if (BinaryOperator *BO = dyn_cast<BinaryOperator>(Op0)) { switch (BO->getOpcode()) { +#if 0 + case Instruction::SRem: + // If we have a signed (X % (2^c)) == 0, turn it into an unsigned one. + if (CI->isNullValue() && isa<ConstantInt>(BO->getOperand(1)) && + BO->hasOneUse()) { + int64_t V = cast<ConstantInt>(BO->getOperand(1))->getSExtValue(); + if (V > 1 && isPowerOf2_64(V)) { + Value *NewRem = InsertNewInstBefore( + BinaryOperator::createURem(BO->getOperand(0), + BO->getOperand(1), + BO->getName()), I); + return BinaryOperator::create( + I.getOpcode(), NewRem, + Constant::getNullValue(NewRem->getType())); + } + } + break; +#endif + case Instruction::Rem: // If we have a signed (X % (2^c)) == 0, turn it into an unsigned one. - if (CI->isNullValue() && isa<ConstantSInt>(BO->getOperand(1)) && - BO->hasOneUse() && - cast<ConstantSInt>(BO->getOperand(1))->getValue() > 1) { - int64_t V = cast<ConstantSInt>(BO->getOperand(1))->getValue(); - if (isPowerOf2_64(V)) { + if (CI->isNullValue() && isa<ConstantInt>(BO->getOperand(1)) && + BO->hasOneUse() && BO->getOperand(1)->getType()->isSigned()) { + int64_t V = cast<ConstantInt>(BO->getOperand(1))->getSExtValue(); + if (V > 1 && isPowerOf2_64(V)) { unsigned L2 = Log2_64(V); const Type *UTy = BO->getType()->getUnsignedVersion(); Value *NewX = InsertNewInstBefore(new CastInst(BO->getOperand(0), UTy, "tmp"), I); - Constant *RHSCst = ConstantUInt::get(UTy, 1ULL << L2); + Constant *RHSCst = ConstantInt::get(UTy, 1ULL << L2); Value *NewRem =InsertNewInstBefore(BinaryOperator::createRem(NewX, RHSCst, BO->getName()), I); return BinaryOperator::create(I.getOpcode(), NewRem, @@ -4489,7 +4517,6 @@ Instruction *InstCombiner::visitSetCondInst(SetCondInst &I) { } } break; - case Instruction::Add: // Replace ((add A, B) != C) with (A != C-B) if B & C are constants. if (ConstantInt *BOp1C = dyn_cast<ConstantInt>(BO->getOperand(1))) { @@ -4602,21 +4629,21 @@ Instruction *InstCombiner::visitSetCondInst(SetCondInst &I) { if (I.getOpcode() == Instruction::SetLT && CI->isNullValue()) // X < 0 => x > 127 return BinaryOperator::createSetGT(CastOp, - ConstantUInt::get(SrcTy, (1ULL << (SrcTySize-1))-1)); + ConstantInt::get(SrcTy, (1ULL << (SrcTySize-1))-1)); else if (I.getOpcode() == Instruction::SetGT && - cast<ConstantSInt>(CI)->getValue() == -1) + cast<ConstantInt>(CI)->getSExtValue() == -1) // X > -1 => x < 128 return BinaryOperator::createSetLT(CastOp, - ConstantUInt::get(SrcTy, 1ULL << (SrcTySize-1))); + ConstantInt::get(SrcTy, 1ULL << (SrcTySize-1))); } else { - ConstantUInt *CUI = cast<ConstantUInt>(CI); + ConstantInt *CUI = cast<ConstantInt>(CI); if (I.getOpcode() == Instruction::SetLT && - CUI->getValue() == 1ULL << (SrcTySize-1)) + CUI->getZExtValue() == 1ULL << (SrcTySize-1)) // X < 128 => X > -1 return BinaryOperator::createSetGT(CastOp, - ConstantSInt::get(SrcTy, -1)); + ConstantInt::get(SrcTy, -1)); else if (I.getOpcode() == Instruction::SetGT && - CUI->getValue() == (1ULL << (SrcTySize-1))-1) + CUI->getZExtValue() == (1ULL << (SrcTySize-1))-1) // X > 127 => X < 0 return BinaryOperator::createSetLT(CastOp, Constant::getNullValue(SrcTy)); @@ -4815,13 +4842,13 @@ Instruction *InstCombiner::visitSetCondInstWithCastAndCast(SetCondInst &SCI) { // We're performing a signed comparison. if (isSignSrc) { // Signed extend and signed comparison. - if (cast<ConstantSInt>(CI)->getValue() < 0) // X < (small) --> false + if (cast<ConstantInt>(CI)->getSExtValue() < 0)// X < (small) --> false Result = ConstantBool::getFalse(); else - Result = ConstantBool::getTrue(); // X < (large) --> true + Result = ConstantBool::getTrue(); // X < (large) --> true } else { // Unsigned extend and signed comparison. - if (cast<ConstantSInt>(CI)->getValue() < 0) + if (cast<ConstantInt>(CI)->getSExtValue() < 0) Result = ConstantBool::getFalse(); else Result = ConstantBool::getTrue(); @@ -4885,7 +4912,7 @@ Instruction *InstCombiner::visitShiftInst(ShiftInst &I) { // shr int -1, X = -1 (for any arithmetic shift rights of ~0) if (!isLeftShift) - if (ConstantSInt *CSI = dyn_cast<ConstantSInt>(Op0)) + if (ConstantInt *CSI = dyn_cast<ConstantInt>(Op0)) if (CSI->isAllOnesValue()) return ReplaceInstUsesWith(I, CSI); @@ -4906,13 +4933,14 @@ Instruction *InstCombiner::visitShiftInst(ShiftInst &I) { } } - if (ConstantUInt *CUI = dyn_cast<ConstantUInt>(Op1)) - if (Instruction *Res = FoldShiftByConstant(Op0, CUI, I)) - return Res; + if (ConstantInt *CUI = dyn_cast<ConstantInt>(Op1)) + if (CUI->getType()->isUnsigned()) + if (Instruction *Res = FoldShiftByConstant(Op0, CUI, I)) + return Res; return 0; } -Instruction *InstCombiner::FoldShiftByConstant(Value *Op0, ConstantUInt *Op1, +Instruction *InstCombiner::FoldShiftByConstant(Value *Op0, ConstantInt *Op1, ShiftInst &I) { bool isLeftShift = I.getOpcode() == Instruction::Shl; bool isSignedShift = Op0->getType()->isSigned(); @@ -4929,11 +4957,11 @@ Instruction *InstCombiner::FoldShiftByConstant(Value *Op0, ConstantUInt *Op1, // of a signed value. // unsigned TypeBits = Op0->getType()->getPrimitiveSizeInBits(); - if (Op1->getValue() >= TypeBits) { + if (Op1->getZExtValue() >= TypeBits) { if (isUnsignedShift || isLeftShift) return ReplaceInstUsesWith(I, Constant::getNullValue(Op0->getType())); else { - I.setOperand(1, ConstantUInt::get(Type::UByteTy, TypeBits-1)); + I.setOperand(1, ConstantInt::get(Type::UByteTy, TypeBits-1)); return &I; } } @@ -5069,7 +5097,7 @@ Instruction *InstCombiner::FoldShiftByConstant(Value *Op0, ConstantUInt *Op1, // operation. // if (isValid && !isLeftShift && isSignedShift) { - uint64_t Val = Op0C->getRawValue(); + uint64_t Val = Op0C->getZExtValue(); isValid = ((Val & (1 << (TypeBits-1))) != 0) == highBitSet; } @@ -5103,7 +5131,7 @@ Instruction *InstCombiner::FoldShiftByConstant(Value *Op0, ConstantUInt *Op1, } } - if (ShiftOp && isa<ConstantUInt>(ShiftOp->getOperand(1))) { + if (ShiftOp && isa<ConstantInt>(ShiftOp->getOperand(1))) { // Find the operands and properties of the input shift. Note that the // signedness of the input shift may differ from the current shift if there // is a noop cast between the two. @@ -5111,10 +5139,10 @@ Instruction *InstCombiner::FoldShiftByConstant(Value *Op0, ConstantUInt *Op1, bool isShiftOfSignedShift = ShiftOp->getType()->isSigned(); bool isShiftOfUnsignedShift = !isShiftOfSignedShift; - ConstantUInt *ShiftAmt1C = cast<ConstantUInt>(ShiftOp->getOperand(1)); + ConstantInt *ShiftAmt1C = cast<ConstantInt>(ShiftOp->getOperand(1)); - unsigned ShiftAmt1 = (unsigned)ShiftAmt1C->getValue(); - unsigned ShiftAmt2 = (unsigned)Op1->getValue(); + unsigned ShiftAmt1 = (unsigned)ShiftAmt1C->getZExtValue(); + unsigned ShiftAmt2 = (unsigned)Op1->getZExtValue(); // Check for (A << c1) << c2 and (A >> c1) >> c2. if (isLeftShift == isShiftOfLeftShift) { @@ -5132,7 +5160,7 @@ Instruction *InstCombiner::FoldShiftByConstant(Value *Op0, ConstantUInt *Op1, if (isShiftOfSignedShift != isSignedShift) Op = InsertNewInstBefore(new CastInst(Op, I.getType(), "tmp"), I); return new ShiftInst(I.getOpcode(), Op, - ConstantUInt::get(Type::UByteTy, Amt)); + ConstantInt::get(Type::UByteTy, Amt)); } // Check for (A << c1) >> c2 or (A >> c1) << c2. If we are dealing with @@ -5159,7 +5187,7 @@ Instruction *InstCombiner::FoldShiftByConstant(Value *Op0, ConstantUInt *Op1, return ReplaceInstUsesWith(I, Mask); // (A << c) >> c === A & c2 } else if (ShiftAmt1 < ShiftAmt2) { return new ShiftInst(I.getOpcode(), Mask, - ConstantUInt::get(Type::UByteTy, ShiftAmt2-ShiftAmt1)); + ConstantInt::get(Type::UByteTy, ShiftAmt2-ShiftAmt1)); } else if (isShiftOfUnsignedShift || isShiftOfLeftShift) { if (isShiftOfUnsignedShift && !isShiftOfLeftShift && isSignedShift) { // Make sure to emit an unsigned shift right, not a signed one. @@ -5167,12 +5195,12 @@ Instruction *InstCombiner::FoldShiftByConstant(Value *Op0, ConstantUInt *Op1, Mask->getType()->getUnsignedVersion(), Op->getName()), I); Mask = new ShiftInst(Instruction::Shr, Mask, - ConstantUInt::get(Type::UByteTy, ShiftAmt1-ShiftAmt2)); + ConstantInt::get(Type::UByteTy, ShiftAmt1-ShiftAmt2)); InsertNewInstBefore(Mask, I); return new CastInst(Mask, I.getType()); } else { return new ShiftInst(ShiftOp->getOpcode(), Mask, - ConstantUInt::get(Type::UByteTy, ShiftAmt1-ShiftAmt2)); + ConstantInt::get(Type::UByteTy, ShiftAmt1-ShiftAmt2)); } } else { // (X >>s C1) << C2 where C1 > C2 === (X >>s (C1-C2)) & mask @@ -5181,7 +5209,7 @@ Instruction *InstCombiner::FoldShiftByConstant(Value *Op0, ConstantUInt *Op1, Mask->getName()), I); Instruction *Shift = new ShiftInst(ShiftOp->getOpcode(), Op, - ConstantUInt::get(Type::UByteTy, ShiftAmt1-ShiftAmt2)); + ConstantInt::get(Type::UByteTy, ShiftAmt1-ShiftAmt2)); InsertNewInstBefore(Shift, I); C = ConstantIntegral::getAllOnesValue(Shift->getType()); @@ -5221,33 +5249,37 @@ Instruction *InstCombiner::FoldShiftByConstant(Value *Op0, ConstantUInt *Op1, static Value *DecomposeSimpleLinearExpr(Value *Val, unsigned &Scale, unsigned &Offset) { assert(Val->getType() == Type::UIntTy && "Unexpected allocation size type!"); - if (ConstantUInt *CI = dyn_cast<ConstantUInt>(Val)) { - Offset = CI->getValue(); - Scale = 1; - return ConstantUInt::get(Type::UIntTy, 0); + if (ConstantInt *CI = dyn_cast<ConstantInt>(Val)) { + if (CI->getType()->isUnsigned()) { + Offset = CI->getZExtValue(); + Scale = 1; + return ConstantInt::get(Type::UIntTy, 0); + } } else if (Instruction *I = dyn_cast<Instruction>(Val)) { if (I->getNumOperands() == 2) { - if (ConstantUInt *CUI = dyn_cast<ConstantUInt>(I->getOperand(1))) { - if (I->getOpcode() == Instruction::Shl) { - // This is a value scaled by '1 << the shift amt'. - Scale = 1U << CUI->getValue(); - Offset = 0; - return I->getOperand(0); - } else if (I->getOpcode() == Instruction::Mul) { - // This value is scaled by 'CUI'. - Scale = CUI->getValue(); - Offset = 0; - return I->getOperand(0); - } else if (I->getOpcode() == Instruction::Add) { - // We have X+C. Check to see if we really have (X*C2)+C1, where C1 is - // divisible by C2. - unsigned SubScale; - Value *SubVal = DecomposeSimpleLinearExpr(I->getOperand(0), SubScale, - Offset); - Offset += CUI->getValue(); - if (SubScale > 1 && (Offset % SubScale == 0)) { - Scale = SubScale; - return SubVal; + if (ConstantInt *CUI = dyn_cast<ConstantInt>(I->getOperand(1))) { + if (CUI->getType()->isUnsigned()) { + if (I->getOpcode() == Instruction::Shl) { + // This is a value scaled by '1 << the shift amt'. + Scale = 1U << CUI->getZExtValue(); + Offset = 0; + return I->getOperand(0); + } else if (I->getOpcode() == Instruction::Mul) { + // This value is scaled by 'CUI'. + Scale = CUI->getZExtValue(); + Offset = 0; + return I->getOperand(0); + } else if (I->getOpcode() == Instruction::Add) { + // We have X+C. Check to see if we really have (X*C2)+C1, + // where C1 is divisible by C2. + unsigned SubScale; + Value *SubVal = + DecomposeSimpleLinearExpr(I->getOperand(0), SubScale, Offset); + Offset += CUI->getZExtValue(); + if (SubScale > 1 && (Offset % SubScale == 0)) { + Scale = SubScale; + return SubVal; + } } } } @@ -5321,9 +5353,12 @@ Instruction *InstCombiner::PromoteCastOfAllocation(CastInst &CI, if (Scale == 1) { Amt = NumElements; } else { - Amt = ConstantUInt::get(Type::UIntTy, Scale); - if (ConstantUInt *CI = dyn_cast<ConstantUInt>(NumElements)) - Amt = ConstantExpr::getMul(CI, cast<ConstantUInt>(Amt)); + // If the allocation size is constant, form a constant mul expression + Amt = ConstantInt::get(Type::UIntTy, Scale); + if (isa<ConstantInt>(NumElements) && NumElements->getType()->isUnsigned()) + Amt = ConstantExpr::getMul( + cast<ConstantInt>(NumElements), cast<ConstantInt>(Amt)); + // otherwise multiply the amount and the number of elements else if (Scale != 1) { Instruction *Tmp = BinaryOperator::createMul(Amt, NumElements, "tmp"); Amt = InsertNewInstBefore(Tmp, AI); @@ -5331,7 +5366,7 @@ Instruction *InstCombiner::PromoteCastOfAllocation(CastInst &CI, } if (unsigned Offset = (AllocElTySize*ArrayOffset)/CastElTySize) { - Value *Off = ConstantUInt::get(Type::UIntTy, Offset); + Value *Off = ConstantInt::get(Type::UIntTy, Offset); Instruction *Tmp = BinaryOperator::createAdd(Amt, Off, "tmp"); Amt = InsertNewInstBefore(Tmp, AI); } @@ -5467,7 +5502,7 @@ Instruction *InstCombiner::visitCastInst(CastInst &CI) { assert(CSrc->getType() != Type::ULongTy && "Cannot have type bigger than ulong!"); uint64_t AndValue = CSrc->getType()->getIntegralTypeMask(); - Constant *AndOp = ConstantUInt::get(A->getType()->getUnsignedVersion(), + Constant *AndOp = ConstantInt::get(A->getType()->getUnsignedVersion(), AndValue); AndOp = ConstantExpr::getCast(AndOp, A->getType()); Instruction *And = BinaryOperator::createAnd(CSrc->getOperand(0), AndOp); @@ -5595,7 +5630,8 @@ Instruction *InstCombiner::visitCastInst(CastInst &CI) { unsigned SrcBitSize = Src->getType()->getPrimitiveSizeInBits(); unsigned DestBitSize = CI.getType()->getPrimitiveSizeInBits(); assert(SrcBitSize < DestBitSize && "Not a zext?"); - Constant *C = ConstantUInt::get(Type::ULongTy, (1ULL << SrcBitSize)-1); + Constant *C = + ConstantInt::get(Type::ULongTy, (1ULL << SrcBitSize)-1); C = ConstantExpr::getCast(C, CI.getType()); return BinaryOperator::createAnd(Res, C); } @@ -5660,7 +5696,7 @@ Instruction *InstCombiner::visitCastInst(CastInst &CI) { // simplifications. if (DestBitSize < SrcBitSize && Src->getType()->isSigned() && isa<ConstantInt>(Op1)) { - unsigned ShiftAmt = cast<ConstantUInt>(Op1)->getValue(); + unsigned ShiftAmt = cast<ConstantInt>(Op1)->getZExtValue(); if (SrcBitSize > ShiftAmt && SrcBitSize-ShiftAmt >= DestBitSize) { // Convert to unsigned. Value *N1 = InsertOperandCastBefore(Op0, @@ -5941,9 +5977,9 @@ Instruction *InstCombiner::visitSelectInst(SelectInst &SI) { if (ConstantInt *TrueValC = dyn_cast<ConstantInt>(TrueVal)) if (ConstantInt *FalseValC = dyn_cast<ConstantInt>(FalseVal)) { // select C, 1, 0 -> cast C to int - if (FalseValC->isNullValue() && TrueValC->getRawValue() == 1) { + if (FalseValC->isNullValue() && TrueValC->getZExtValue() == 1) { return new CastInst(CondVal, SI.getType()); - } else if (TrueValC->isNullValue() && FalseValC->getRawValue() == 1) { + } else if (TrueValC->isNullValue() && FalseValC->getZExtValue() == 1) { // select C, 0, 1 -> cast !C to int Value *NotCond = InsertNewInstBefore(BinaryOperator::createNot(CondVal, @@ -5963,7 +5999,7 @@ Instruction *InstCombiner::visitSelectInst(SelectInst &SI) { IC->getOpcode() == Instruction::SetLT; else { unsigned Bits = CmpCst->getType()->getPrimitiveSizeInBits(); - CanXForm = (CmpCst->getRawValue() == ~0ULL >> (64-Bits+1)) && + CanXForm = (CmpCst->getZExtValue() == ~0ULL >> (64-Bits+1)) && IC->getOpcode() == Instruction::SetGT; } @@ -5978,7 +6014,7 @@ Instruction *InstCombiner::visitSelectInst(SelectInst &SI) { // Now that X is signed, we have to make the all ones value. Do // this by inserting a new SRA. unsigned Bits = X->getType()->getPrimitiveSizeInBits(); - Constant *ShAmt = ConstantUInt::get(Type::UByteTy, Bits-1); + Constant *ShAmt = ConstantInt::get(Type::UByteTy, Bits-1); Instruction *SRA = new ShiftInst(Instruction::Shr, X, ShAmt, "ones"); InsertNewInstBefore(SRA, SI); @@ -6245,7 +6281,7 @@ Instruction *InstCombiner::visitCallInst(CallInst &CI) { if (NumBytes->isNullValue()) return EraseInstFromFunction(CI); if (ConstantInt *CI = dyn_cast<ConstantInt>(NumBytes)) - if (CI->getRawValue() == 1) { + if (CI->getZExtValue() == 1) { // Replace the instruction with just byte operations. We would // transform other cases to loads/stores, but we don't know if // alignment is sufficient. @@ -6278,14 +6314,14 @@ Instruction *InstCombiner::visitCallInst(CallInst &CI) { unsigned Alignment1 = GetKnownAlignment(MI->getOperand(1), TD); unsigned Alignment2 = GetKnownAlignment(MI->getOperand(2), TD); unsigned Align = std::min(Alignment1, Alignment2); - if (MI->getAlignment()->getRawValue() < Align) { - MI->setAlignment(ConstantUInt::get(Type::UIntTy, Align)); + if (MI->getAlignment()->getZExtValue() < Align) { + MI->setAlignment(ConstantInt::get(Type::UIntTy, Align)); Changed = true; } } else if (isa<MemSetInst>(MI)) { unsigned Alignment = GetKnownAlignment(MI->getDest(), TD); - if (MI->getAlignment()->getRawValue() < Alignment) { - MI->setAlignment(ConstantUInt::get(Type::UIntTy, Alignment)); + if (MI->getAlignment()->getZExtValue() < Alignment) { + MI->setAlignment(ConstantInt::get(Type::UIntTy, Alignment)); Changed = true; } } @@ -6368,7 +6404,7 @@ Instruction *InstCombiner::visitCallInst(CallInst &CI) { for (unsigned i = 0; i != 16; ++i) { if (isa<UndefValue>(Mask->getOperand(i))) continue; - unsigned Idx =cast<ConstantInt>(Mask->getOperand(i))->getRawValue(); + unsigned Idx =cast<ConstantInt>(Mask->getOperand(i))->getZExtValue(); Idx &= 31; // Match the hardware behavior. if (ExtractedElts[Idx] == 0) { @@ -6542,14 +6578,14 @@ bool InstCombiner::transformConstExprCastCall(CallSite CS) { for (unsigned i = 0, e = NumCommonArgs; i != e; ++i, ++AI) { const Type *ParamTy = FT->getParamType(i); const Type *ActTy = (*AI)->getType(); - ConstantSInt* c = dyn_cast<ConstantSInt>(*AI); + ConstantInt* c = dyn_cast<ConstantInt>(*AI); //Either we can cast directly, or we can upconvert the argument bool isConvertible = ActTy->isLosslesslyConvertibleTo(ParamTy) || (ParamTy->isIntegral() && ActTy->isIntegral() && ParamTy->isSigned() == ActTy->isSigned() && ParamTy->getPrimitiveSize() >= ActTy->getPrimitiveSize()) || (c && ParamTy->getPrimitiveSize() >= ActTy->getPrimitiveSize() && - c->getValue() > 0); + c->getSExtValue() > 0); if (Callee->isExternal() && !isConvertible) return false; } @@ -6874,11 +6910,12 @@ Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) { // If this is a constant idx, make sure to canonicalize it to be a signed // operand, otherwise CSE and other optimizations are pessimized. - if (ConstantUInt *CUI = dyn_cast<ConstantUInt>(Op)) { - GEP.setOperand(i, ConstantExpr::getCast(CUI, - CUI->getType()->getSignedVersion())); - MadeChange = true; - } + if (ConstantInt *CUI = dyn_cast<ConstantInt>(Op)) + if (CUI->getType()->isUnsigned()) { + GEP.setOperand(i, + ConstantExpr::getCast(CUI, CUI->getType()->getSignedVersion())); + MadeChange = true; + } } if (MadeChange) return &GEP; @@ -7049,11 +7086,12 @@ Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) { } else if (Instruction *Inst =dyn_cast<Instruction>(GEP.getOperand(1))){ if (Inst->getOpcode() == Instruction::Shl && isa<ConstantInt>(Inst->getOperand(1))) { - unsigned ShAmt =cast<ConstantUInt>(Inst->getOperand(1))->getValue(); + unsigned ShAmt = + cast<ConstantInt>(Inst->getOperand(1))->getZExtValue(); if (Inst->getType()->isSigned()) - Scale = ConstantSInt::get(Inst->getType(), 1ULL << ShAmt); + Scale = ConstantInt::get(Inst->getType(), 1ULL << ShAmt); else - Scale = ConstantUInt::get(Inst->getType(), 1ULL << ShAmt); + Scale = ConstantInt::get(Inst->getType(), 1ULL << ShAmt); NewIdx = Inst->getOperand(0); } else if (Inst->getOpcode() == Instruction::Mul && isa<ConstantInt>(Inst->getOperand(1))) { @@ -7064,15 +7102,11 @@ Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) { // If the index will be to exactly the right offset with the scale taken // out, perform the transformation. - if (Scale && Scale->getRawValue() % ArrayEltSize == 0) { - if (ConstantSInt *C = dyn_cast<ConstantSInt>(Scale)) - Scale = ConstantSInt::get(C->getType(), - (int64_t)C->getRawValue() / - (int64_t)ArrayEltSize); - else - Scale = ConstantUInt::get(Scale->getType(), - Scale->getRawValue() / ArrayEltSize); - if (Scale->getRawValue() != 1) { + if (Scale && Scale->getZExtValue() % ArrayEltSize == 0) { + if (ConstantInt *C = dyn_cast<ConstantInt>(Scale)) + Scale = ConstantInt::get(Scale->getType(), + Scale->getZExtValue() / ArrayEltSize); + if (Scale->getZExtValue() != 1) { Constant *C = ConstantExpr::getCast(Scale, NewIdx->getType()); Instruction *Sc = BinaryOperator::createMul(NewIdx, C, "idxscale"); NewIdx = InsertNewInstBefore(Sc, GEP); @@ -7095,8 +7129,9 @@ Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) { Instruction *InstCombiner::visitAllocationInst(AllocationInst &AI) { // Convert: malloc Ty, C - where C is a constant != 1 into: malloc [C x Ty], 1 if (AI.isArrayAllocation()) // Check C != 1 - if (const ConstantUInt *C = dyn_cast<ConstantUInt>(AI.getArraySize())) { - const Type *NewTy = ArrayType::get(AI.getAllocatedType(), C->getValue()); + if (const ConstantInt *C = dyn_cast<ConstantInt>(AI.getArraySize())) { + const Type *NewTy = + ArrayType::get(AI.getAllocatedType(), C->getZExtValue()); AllocationInst *New = 0; // Create and insert the replacement instruction... @@ -7688,7 +7723,7 @@ static std::vector<unsigned> getShuffleMask(const ShuffleVectorInst *SVI) { if (isa<UndefValue>(CP->getOperand(i))) Result.push_back(NElts*2); // undef -> 8 else - Result.push_back(cast<ConstantUInt>(CP->getOperand(i))->getValue()); + Result.push_back(cast<ConstantInt>(CP->getOperand(i))->getZExtValue()); return Result; } @@ -7710,12 +7745,14 @@ static Value *FindScalarElement(Value *V, unsigned EltNo) { return CP->getOperand(EltNo); else if (InsertElementInst *III = dyn_cast<InsertElementInst>(V)) { // If this is an insert to a variable element, we don't know what it is. - if (!isa<ConstantUInt>(III->getOperand(2))) return 0; - unsigned IIElt = cast<ConstantUInt>(III->getOperand(2))->getValue(); + if (!isa<ConstantInt>(III->getOperand(2))) + return 0; + unsigned IIElt = cast<ConstantInt>(III->getOperand(2))->getZExtValue(); // If this is an insert to the element we are looking for, return the // inserted value. - if (EltNo == IIElt) return III->getOperand(1); + if (EltNo == IIElt) + return III->getOperand(1); // Otherwise, the insertelement doesn't modify the value, recurse on its // vector input. @@ -7759,21 +7796,22 @@ Instruction *InstCombiner::visitExtractElementInst(ExtractElementInst &EI) { // If extracting a specified index from the vector, see if we can recursively // find a previously computed scalar that was inserted into the vector. - if (ConstantUInt *IdxC = dyn_cast<ConstantUInt>(EI.getOperand(1))) { + if (ConstantInt *IdxC = dyn_cast<ConstantInt>(EI.getOperand(1))) { // This instruction only demands the single element from the input vector. // If the input vector has a single use, simplify it based on this use // property. + uint64_t IndexVal = IdxC->getZExtValue(); if (EI.getOperand(0)->hasOneUse()) { uint64_t UndefElts; if (Value *V = SimplifyDemandedVectorElts(EI.getOperand(0), - 1 << IdxC->getValue(), + 1 << IndexVal, UndefElts)) { EI.setOperand(0, V); return &EI; } } - if (Value *Elt = FindScalarElement(EI.getOperand(0), IdxC->getValue())) + if (Value *Elt = FindScalarElement(EI.getOperand(0), IndexVal)) return ReplaceInstUsesWith(EI, Elt); } @@ -7819,8 +7857,8 @@ Instruction *InstCombiner::visitExtractElementInst(ExtractElementInst &EI) { } else if (ShuffleVectorInst *SVI = dyn_cast<ShuffleVectorInst>(I)) { // If this is extracting an element from a shufflevector, figure out where // it came from and extract from the appropriate input element instead. - if (ConstantUInt *Elt = dyn_cast<ConstantUInt>(EI.getOperand(1))) { - unsigned SrcIdx = getShuffleMask(SVI)[Elt->getValue()]; + if (ConstantInt *Elt = dyn_cast<ConstantInt>(EI.getOperand(1))) { + unsigned SrcIdx = getShuffleMask(SVI)[Elt->getZExtValue()]; Value *Src; if (SrcIdx < SVI->getType()->getNumElements()) Src = SVI->getOperand(0); @@ -7851,11 +7889,11 @@ static bool CollectSingleShuffleElements(Value *V, Value *LHS, Value *RHS, return true; } else if (V == LHS) { for (unsigned i = 0; i != NumElts; ++i) - Mask.push_back(ConstantUInt::get(Type::UIntTy, i)); + Mask.push_back(ConstantInt::get(Type::UIntTy, i)); return true; } else if (V == RHS) { for (unsigned i = 0; i != NumElts; ++i) - Mask.push_back(ConstantUInt::get(Type::UIntTy, i+NumElts)); + Mask.push_back(ConstantInt::get(Type::UIntTy, i+NumElts)); return true; } else if (InsertElementInst *IEI = dyn_cast<InsertElementInst>(V)) { // If this is an insert of an extract from some other vector, include it. @@ -7865,7 +7903,7 @@ static bool CollectSingleShuffleElements(Value *V, Value *LHS, Value *RHS, if (!isa<ConstantInt>(IdxOp)) return false; - unsigned InsertedIdx = cast<ConstantInt>(IdxOp)->getRawValue(); + unsigned InsertedIdx = cast<ConstantInt>(IdxOp)->getZExtValue(); if (isa<UndefValue>(ScalarOp)) { // inserting undef into vector. // Okay, we can handle this if the vector we are insertinting into is @@ -7879,7 +7917,7 @@ static bool CollectSingleShuffleElements(Value *V, Value *LHS, Value *RHS, if (isa<ConstantInt>(EI->getOperand(1)) && EI->getOperand(0)->getType() == V->getType()) { unsigned ExtractedIdx = - cast<ConstantInt>(EI->getOperand(1))->getRawValue(); + cast<ConstantInt>(EI->getOperand(1))->getZExtValue(); // This must be extracting from either LHS or RHS. if (EI->getOperand(0) == LHS || EI->getOperand(0) == RHS) { @@ -7889,11 +7927,11 @@ static bool CollectSingleShuffleElements(Value *V, Value *LHS, Value *RHS, // If so, update the mask to reflect the inserted value. if (EI->getOperand(0) == LHS) { Mask[InsertedIdx & (NumElts-1)] = - ConstantUInt::get(Type::UIntTy, ExtractedIdx); + ConstantInt::get(Type::UIntTy, ExtractedIdx); } else { assert(EI->getOperand(0) == RHS); Mask[InsertedIdx & (NumElts-1)] = - ConstantUInt::get(Type::UIntTy, ExtractedIdx+NumElts); + ConstantInt::get(Type::UIntTy, ExtractedIdx+NumElts); } return true; @@ -7921,7 +7959,7 @@ static Value *CollectShuffleElements(Value *V, std::vector<Constant*> &Mask, Mask.assign(NumElts, UndefValue::get(Type::UIntTy)); return V; } else if (isa<ConstantAggregateZero>(V)) { - Mask.assign(NumElts, ConstantUInt::get(Type::UIntTy, 0)); + Mask.assign(NumElts, ConstantInt::get(Type::UIntTy, 0)); return V; } else if (InsertElementInst *IEI = dyn_cast<InsertElementInst>(V)) { // If this is an insert of an extract from some other vector, include it. @@ -7933,8 +7971,8 @@ static Value *CollectShuffleElements(Value *V, std::vector<Constant*> &Mask, if (isa<ConstantInt>(EI->getOperand(1)) && isa<ConstantInt>(IdxOp) && EI->getOperand(0)->getType() == V->getType()) { unsigned ExtractedIdx = - cast<ConstantInt>(EI->getOperand(1))->getRawValue(); - unsigned InsertedIdx = cast<ConstantInt>(IdxOp)->getRawValue(); + cast<ConstantInt>(EI->getOperand(1))->getZExtValue(); + unsigned InsertedIdx = cast<ConstantInt>(IdxOp)->getZExtValue(); // Either the extracted from or inserted into vector must be RHSVec, // otherwise we'd end up with a shuffle of three inputs. @@ -7942,7 +7980,7 @@ static Value *CollectShuffleElements(Value *V, std::vector<Constant*> &Mask, RHS = EI->getOperand(0); Value *V = CollectShuffleElements(VecOp, Mask, RHS); Mask[InsertedIdx & (NumElts-1)] = - ConstantUInt::get(Type::UIntTy, NumElts+ExtractedIdx); + ConstantInt::get(Type::UIntTy, NumElts+ExtractedIdx); return V; } @@ -7951,7 +7989,7 @@ static Value *CollectShuffleElements(Value *V, std::vector<Constant*> &Mask, // Everything but the extracted element is replaced with the RHS. for (unsigned i = 0; i != NumElts; ++i) { if (i != InsertedIdx) - Mask[i] = ConstantUInt::get(Type::UIntTy, NumElts+i); + Mask[i] = ConstantInt::get(Type::UIntTy, NumElts+i); } return V; } @@ -7968,7 +8006,7 @@ static Value *CollectShuffleElements(Value *V, std::vector<Constant*> &Mask, // Otherwise, can't do anything fancy. Return an identity vector. for (unsigned i = 0; i != NumElts; ++i) - Mask.push_back(ConstantUInt::get(Type::UIntTy, i)); + Mask.push_back(ConstantInt::get(Type::UIntTy, i)); return V; } @@ -7983,8 +8021,8 @@ Instruction *InstCombiner::visitInsertElementInst(InsertElementInst &IE) { if (isa<ConstantInt>(EI->getOperand(1)) && isa<ConstantInt>(IdxOp) && EI->getOperand(0)->getType() == IE.getType()) { unsigned NumVectorElts = IE.getType()->getNumElements(); - unsigned ExtractedIdx=cast<ConstantInt>(EI->getOperand(1))->getRawValue(); - unsigned InsertedIdx = cast<ConstantInt>(IdxOp)->getRawValue(); + unsigned ExtractedIdx=cast<ConstantInt>(EI->getOperand(1))->getZExtValue(); + unsigned InsertedIdx = cast<ConstantInt>(IdxOp)->getZExtValue(); if (ExtractedIdx >= NumVectorElts) // Out of range extract. return ReplaceInstUsesWith(IE, VecOp); @@ -8010,10 +8048,10 @@ Instruction *InstCombiner::visitInsertElementInst(InsertElementInst &IE) { Mask.assign(NumVectorElts, UndefValue::get(Type::UIntTy)); else { assert(isa<ConstantAggregateZero>(VecOp) && "Unknown thing"); - Mask.assign(NumVectorElts, ConstantUInt::get(Type::UIntTy, + Mask.assign(NumVectorElts, ConstantInt::get(Type::UIntTy, NumVectorElts)); } - Mask[InsertedIdx] = ConstantUInt::get(Type::UIntTy, ExtractedIdx); + Mask[InsertedIdx] = ConstantInt::get(Type::UIntTy, ExtractedIdx); return new ShuffleVectorInst(EI->getOperand(0), VecOp, ConstantPacked::get(Mask)); } @@ -8068,7 +8106,7 @@ Instruction *InstCombiner::visitShuffleVectorInst(ShuffleVectorInst &SVI) { Mask[i] = 2*e; // Turn into undef. else Mask[i] &= (e-1); // Force to LHS. - Elts.push_back(ConstantUInt::get(Type::UIntTy, Mask[i])); + Elts.push_back(ConstantInt::get(Type::UIntTy, Mask[i])); } } SVI.setOperand(0, SVI.getOperand(1)); @@ -8123,7 +8161,7 @@ Instruction *InstCombiner::visitShuffleVectorInst(ShuffleVectorInst &SVI) { if (NewMask[i] >= e*2) { Elts.push_back(UndefValue::get(Type::UIntTy)); } else { - Elts.push_back(ConstantUInt::get(Type::UIntTy, NewMask[i])); + Elts.push_back(ConstantInt::get(Type::UIntTy, NewMask[i])); } } return new ShuffleVectorInst(LHSSVI->getOperand(0), @@ -8193,7 +8231,7 @@ static Constant *OptimizeConstantExpr(ConstantExpr *CE, const TargetData *TD) { if (isFoldableGEP) { std::vector<Value*> Ops(CE->op_begin()+1, CE->op_end()); uint64_t Offset = TD->getIndexedOffset(Ptr->getType(), Ops); - Constant *C = ConstantUInt::get(Type::ULongTy, Offset); + Constant *C = ConstantInt::get(Type::ULongTy, Offset); C = ConstantExpr::getCast(C, TD->getIntPtrType()); return ConstantExpr::getCast(C, CE->getType()); } diff --git a/lib/Transforms/Scalar/LoopStrengthReduce.cpp b/lib/Transforms/Scalar/LoopStrengthReduce.cpp index 7f02488..e498860 100644 --- a/lib/Transforms/Scalar/LoopStrengthReduce.cpp +++ b/lib/Transforms/Scalar/LoopStrengthReduce.cpp @@ -264,7 +264,7 @@ SCEVHandle LoopStrengthReduce::GetExpressionSCEV(Instruction *Exp, Loop *L) { // operand. if (const StructType *STy = dyn_cast<StructType>(*GTI)) { const StructLayout *SL = TD->getStructLayout(STy); - unsigned Idx = cast<ConstantUInt>(GEP->getOperand(i))->getValue(); + unsigned Idx = cast<ConstantInt>(GEP->getOperand(i))->getZExtValue(); uint64_t Offset = SL->MemberOffsets[Idx]; GEPVal = SCEVAddExpr::get(GEPVal, SCEVUnknown::getIntegerSCEV(Offset, UIntPtrTy)); @@ -275,7 +275,7 @@ SCEVHandle LoopStrengthReduce::GetExpressionSCEV(Instruction *Exp, Loop *L) { uint64_t TypeSize = TD->getTypeSize(GTI.getIndexedType()); if (TypeSize != 1) Idx = SCEVMulExpr::get(Idx, - SCEVConstant::get(ConstantUInt::get(UIntPtrTy, + SCEVConstant::get(ConstantInt::get(UIntPtrTy, TypeSize))); GEPVal = SCEVAddExpr::get(GEPVal, Idx); } @@ -861,7 +861,7 @@ RemoveCommonExpressionsFromUseBases(std::vector<BasedUser> &Uses) { /// static bool isZero(SCEVHandle &V) { if (SCEVConstant *SC = dyn_cast<SCEVConstant>(V)) - return SC->getValue()->getRawValue() == 0; + return SC->getValue()->getZExtValue() == 0; return false; } diff --git a/lib/Transforms/Scalar/LoopUnroll.cpp b/lib/Transforms/Scalar/LoopUnroll.cpp index f1a826e..9c59dd3 100644 --- a/lib/Transforms/Scalar/LoopUnroll.cpp +++ b/lib/Transforms/Scalar/LoopUnroll.cpp @@ -190,8 +190,8 @@ bool LoopUnroll::visitLoop(Loop *L) { ConstantInt *TripCountC = dyn_cast_or_null<ConstantInt>(L->getTripCount()); if (!TripCountC) return Changed; // Must have constant trip count! - uint64_t TripCountFull = TripCountC->getRawValue(); - if (TripCountFull != TripCountC->getRawValue() || TripCountFull == 0) + uint64_t TripCountFull = TripCountC->getZExtValue(); + if (TripCountFull != TripCountC->getZExtValue() || TripCountFull == 0) return Changed; // More than 2^32 iterations??? unsigned LoopSize = ApproximateLoopSize(L); diff --git a/lib/Transforms/Scalar/LowerGC.cpp b/lib/Transforms/Scalar/LowerGC.cpp index 851009c..6a07691 100644 --- a/lib/Transforms/Scalar/LowerGC.cpp +++ b/lib/Transforms/Scalar/LowerGC.cpp @@ -222,8 +222,8 @@ bool LowerGC::runOnFunction(Function &F) { BasicBlock::iterator IP = AI; while (isa<AllocaInst>(IP)) ++IP; - Constant *Zero = ConstantUInt::get(Type::UIntTy, 0); - Constant *One = ConstantUInt::get(Type::UIntTy, 1); + Constant *Zero = ConstantInt::get(Type::UIntTy, 0); + Constant *One = ConstantInt::get(Type::UIntTy, 1); // Get a pointer to the prev pointer. std::vector<Value*> Par; @@ -237,11 +237,11 @@ bool LowerGC::runOnFunction(Function &F) { new StoreInst(PrevPtr, PrevPtrPtr, IP); // Set the number of elements in this record. - Par[1] = ConstantUInt::get(Type::UIntTy, 1); + Par[1] = ConstantInt::get(Type::UIntTy, 1); Value *NumEltsPtr = new GetElementPtrInst(AI, Par, "numeltsptr", IP); - new StoreInst(ConstantUInt::get(Type::UIntTy, GCRoots.size()), NumEltsPtr,IP); + new StoreInst(ConstantInt::get(Type::UIntTy, GCRoots.size()), NumEltsPtr,IP); - Par[1] = ConstantUInt::get(Type::UIntTy, 2); + Par[1] = ConstantInt::get(Type::UIntTy, 2); Par.resize(4); const PointerType *PtrLocTy = @@ -251,7 +251,7 @@ bool LowerGC::runOnFunction(Function &F) { // Initialize all of the gcroot records now, and eliminate them as we go. for (unsigned i = 0, e = GCRoots.size(); i != e; ++i) { // Initialize the meta-data pointer. - Par[2] = ConstantUInt::get(Type::UIntTy, i); + Par[2] = ConstantInt::get(Type::UIntTy, i); Par[3] = One; Value *MetaDataPtr = new GetElementPtrInst(AI, Par, "MetaDataPtr", IP); assert(isa<Constant>(GCRoots[i]->getOperand(2)) && "Must be a constant"); diff --git a/lib/Transforms/Scalar/LowerPacked.cpp b/lib/Transforms/Scalar/LowerPacked.cpp index 79a55ee..5eb8911 100644 --- a/lib/Transforms/Scalar/LowerPacked.cpp +++ b/lib/Transforms/Scalar/LowerPacked.cpp @@ -209,7 +209,7 @@ void LowerPacked::visitLoadInst(LoadInst& LI) if (const PackedType* PKT = dyn_cast<PackedType>(LI.getType())) { // Initialization, Idx is needed for getelementptr needed later std::vector<Value*> Idx(2); - Idx[0] = ConstantUInt::get(Type::UIntTy,0); + Idx[0] = ConstantInt::get(Type::UIntTy,0); ArrayType* AT = ArrayType::get(PKT->getContainedType(0), PKT->getNumElements()); @@ -227,7 +227,7 @@ void LowerPacked::visitLoadInst(LoadInst& LI) for (unsigned i = 0, e = PKT->getNumElements(); i != e; ++i) { // Calculate the second index we will need - Idx[1] = ConstantUInt::get(Type::UIntTy,i); + Idx[1] = ConstantInt::get(Type::UIntTy,i); // Get the pointer Value* val = new GetElementPtrInst(array, @@ -283,7 +283,7 @@ void LowerPacked::visitStoreInst(StoreInst& SI) dyn_cast<PackedType>(SI.getOperand(0)->getType())) { // We will need this for getelementptr std::vector<Value*> Idx(2); - Idx[0] = ConstantUInt::get(Type::UIntTy,0); + Idx[0] = ConstantInt::get(Type::UIntTy,0); ArrayType* AT = ArrayType::get(PKT->getContainedType(0), PKT->getNumElements()); @@ -301,7 +301,7 @@ void LowerPacked::visitStoreInst(StoreInst& SI) for (unsigned i = 0, e = PKT->getNumElements(); i != e; ++i) { // Generate the indices for getelementptr - Idx[1] = ConstantUInt::get(Type::UIntTy,i); + Idx[1] = ConstantInt::get(Type::UIntTy,i); Value* val = new GetElementPtrInst(array, Idx, "store.ge." + @@ -346,17 +346,17 @@ void LowerPacked::visitExtractElementInst(ExtractElementInst& EI) const PackedType *PTy = cast<PackedType>(EI.getOperand(0)->getType()); Value *op1 = EI.getOperand(1); - if (ConstantUInt *C = dyn_cast<ConstantUInt>(op1)) { - EI.replaceAllUsesWith(op0Vals[C->getValue()]); + if (ConstantInt *C = dyn_cast<ConstantInt>(op1)) { + EI.replaceAllUsesWith(op0Vals[C->getZExtValue()]); } else { AllocaInst *alloca = new AllocaInst(PTy->getElementType(), - ConstantUInt::get(Type::UIntTy, PTy->getNumElements()), + ConstantInt::get(Type::UIntTy, PTy->getNumElements()), EI.getName() + ".alloca", EI.getParent()->getParent()->getEntryBlock().begin()); for (unsigned i = 0; i < PTy->getNumElements(); ++i) { GetElementPtrInst *GEP = - new GetElementPtrInst(alloca, ConstantUInt::get(Type::UIntTy, i), + new GetElementPtrInst(alloca, ConstantInt::get(Type::UIntTy, i), "store.ge", &EI); new StoreInst(op0Vals[i], GEP, &EI); } @@ -378,8 +378,8 @@ void LowerPacked::visitInsertElementInst(InsertElementInst& IE) std::vector<Value*> result; result.reserve(Vals.size()); - if (ConstantUInt *C = dyn_cast<ConstantUInt>(Idx)) { - unsigned idxVal = C->getValue(); + if (ConstantInt *C = dyn_cast<ConstantInt>(Idx)) { + unsigned idxVal = C->getZExtValue(); for (unsigned i = 0; i != Vals.size(); ++i) { result.push_back(i == idxVal ? Elt : Vals[i]); } @@ -387,7 +387,7 @@ void LowerPacked::visitInsertElementInst(InsertElementInst& IE) for (unsigned i = 0; i != Vals.size(); ++i) { SetCondInst *setcc = new SetCondInst(Instruction::SetEQ, Idx, - ConstantUInt::get(Type::UIntTy, i), + ConstantInt::get(Type::UIntTy, i), "setcc", &IE); SelectInst *select = new SelectInst(setcc, Elt, Vals[i], "select", &IE); diff --git a/lib/Transforms/Scalar/Reassociate.cpp b/lib/Transforms/Scalar/Reassociate.cpp index 250d62b..64b7b12 100644 --- a/lib/Transforms/Scalar/Reassociate.cpp +++ b/lib/Transforms/Scalar/Reassociate.cpp @@ -549,7 +549,7 @@ Value *Reassociate::OptimizeExpression(BinaryOperator *I, if (CstVal->isNullValue()) { // ... * 0 -> 0 ++NumAnnihil; return CstVal; - } else if (cast<ConstantInt>(CstVal)->getRawValue() == 1) { + } else if (cast<ConstantInt>(CstVal)->getZExtValue() == 1) { Ops.pop_back(); // ... * 1 -> ... } break; diff --git a/lib/Transforms/Scalar/ScalarReplAggregates.cpp b/lib/Transforms/Scalar/ScalarReplAggregates.cpp index 87952be..496449f 100644 --- a/lib/Transforms/Scalar/ScalarReplAggregates.cpp +++ b/lib/Transforms/Scalar/ScalarReplAggregates.cpp @@ -203,7 +203,7 @@ bool SROA::performScalarRepl(Function &F) { GetElementPtrInst *GEPI = cast<GetElementPtrInst>(User); // We now know that the GEP is of the form: GEP <ptr>, 0, <cst> unsigned Idx = - (unsigned)cast<ConstantInt>(GEPI->getOperand(2))->getRawValue(); + (unsigned)cast<ConstantInt>(GEPI->getOperand(2))->getZExtValue(); assert(Idx < ElementAllocas.size() && "Index out of range?"); AllocaInst *AllocaToUse = ElementAllocas[Idx]; @@ -306,7 +306,7 @@ int SROA::isSafeUseOfAllocation(Instruction *User) { // Check to make sure that index falls within the array. If not, // something funny is going on, so we won't do the optimization. // - if (cast<ConstantInt>(GEPI->getOperand(2))->getRawValue() >= NumElements) + if (cast<ConstantInt>(GEPI->getOperand(2))->getZExtValue() >= NumElements) return 0; // We cannot scalar repl this level of the array unless any array @@ -320,7 +320,7 @@ int SROA::isSafeUseOfAllocation(Instruction *User) { const ArrayType *SubArrayTy = cast<ArrayType>(*I); uint64_t NumElements = SubArrayTy->getNumElements(); if (!isa<ConstantInt>(I.getOperand())) return 0; - if (cast<ConstantInt>(I.getOperand())->getRawValue() >= NumElements) + if (cast<ConstantInt>(I.getOperand())->getZExtValue() >= NumElements) return 0; } @@ -499,7 +499,7 @@ const Type *SROA::CanConvertToScalar(Value *V, bool &IsNotTrivial) { } else if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(User)) { // Check to see if this is stepping over an element: GEP Ptr, int C if (GEP->getNumOperands() == 2 && isa<ConstantInt>(GEP->getOperand(1))) { - unsigned Idx = cast<ConstantInt>(GEP->getOperand(1))->getRawValue(); + unsigned Idx = cast<ConstantInt>(GEP->getOperand(1))->getZExtValue(); unsigned ElSize = TD.getTypeSize(PTy->getElementType()); unsigned BitOffset = Idx*ElSize*8; if (BitOffset > 64 || !isPowerOf2_32(ElSize)) return 0; @@ -520,7 +520,7 @@ const Type *SROA::CanConvertToScalar(Value *V, bool &IsNotTrivial) { // We are stepping into an element, e.g. a structure or an array: // GEP Ptr, int 0, uint C const Type *AggTy = PTy->getElementType(); - unsigned Idx = cast<ConstantInt>(GEP->getOperand(2))->getRawValue(); + unsigned Idx = cast<ConstantInt>(GEP->getOperand(2))->getZExtValue(); if (const ArrayType *ATy = dyn_cast<ArrayType>(AggTy)) { if (Idx >= ATy->getNumElements()) return 0; // Out of range. @@ -608,13 +608,13 @@ void SROA::ConvertUsesToScalar(Value *Ptr, AllocaInst *NewAI, unsigned Offset) { if (const PackedType *PTy = dyn_cast<PackedType>(NV->getType())) { // Must be an element access. unsigned Elt = Offset/(TD.getTypeSize(PTy->getElementType())*8); - NV = new ExtractElementInst(NV, ConstantUInt::get(Type::UIntTy, Elt), + NV = new ExtractElementInst(NV, ConstantInt::get(Type::UIntTy, Elt), "tmp", LI); } else { assert(NV->getType()->isInteger() && "Unknown promotion!"); if (Offset && Offset < TD.getTypeSize(NV->getType())*8) NV = new ShiftInst(Instruction::Shr, NV, - ConstantUInt::get(Type::UByteTy, Offset), + ConstantInt::get(Type::UByteTy, Offset), LI->getName(), LI); NV = new CastInst(NV, LI->getType(), LI->getName(), LI); } @@ -635,7 +635,7 @@ void SROA::ConvertUsesToScalar(Value *Ptr, AllocaInst *NewAI, unsigned Offset) { // Must be an element insertion. unsigned Elt = Offset/(TD.getTypeSize(PTy->getElementType())*8); SV = new InsertElementInst(Old, SV, - ConstantUInt::get(Type::UIntTy, Elt), + ConstantInt::get(Type::UIntTy, Elt), "tmp", SI); } else { // If SV is signed, convert it to unsigned, so that the next cast zero @@ -646,7 +646,7 @@ void SROA::ConvertUsesToScalar(Value *Ptr, AllocaInst *NewAI, unsigned Offset) { SV = new CastInst(SV, Old->getType(), SV->getName(), SI); if (Offset && Offset < TD.getTypeSize(SV->getType())*8) SV = new ShiftInst(Instruction::Shl, SV, - ConstantUInt::get(Type::UByteTy, Offset), + ConstantInt::get(Type::UByteTy, Offset), SV->getName()+".adj", SI); // Mask out the bits we are about to insert from the old value. unsigned TotalBits = TD.getTypeSize(SV->getType())*8; @@ -657,7 +657,7 @@ void SROA::ConvertUsesToScalar(Value *Ptr, AllocaInst *NewAI, unsigned Offset) { if (TotalBits != 64) Mask = Mask & ((1ULL << TotalBits)-1); Old = BinaryOperator::createAnd(Old, - ConstantUInt::get(Old->getType(), Mask), + ConstantInt::get(Old->getType(), Mask), Old->getName()+".mask", SI); SV = BinaryOperator::createOr(Old, SV, SV->getName()+".ins", SI); } @@ -688,7 +688,7 @@ void SROA::ConvertUsesToScalar(Value *Ptr, AllocaInst *NewAI, unsigned Offset) { // Check to see if this is stepping over an element: GEP Ptr, int C unsigned NewOffset = Offset; if (GEP->getNumOperands() == 2) { - unsigned Idx = cast<ConstantInt>(GEP->getOperand(1))->getRawValue(); + unsigned Idx = cast<ConstantInt>(GEP->getOperand(1))->getZExtValue(); unsigned BitOffset = Idx*AggSizeInBits; if (TD.isLittleEndian() || isVectorInsert) @@ -698,7 +698,7 @@ void SROA::ConvertUsesToScalar(Value *Ptr, AllocaInst *NewAI, unsigned Offset) { } else if (GEP->getNumOperands() == 3) { // We know that operand #2 is zero. - unsigned Idx = cast<ConstantInt>(GEP->getOperand(2))->getRawValue(); + unsigned Idx = cast<ConstantInt>(GEP->getOperand(2))->getZExtValue(); const Type *AggTy = AggPtrTy->getElementType(); if (const SequentialType *SeqTy = dyn_cast<SequentialType>(AggTy)) { unsigned ElSizeBits = TD.getTypeSize(SeqTy->getElementType())*8; diff --git a/lib/Transforms/TransformInternals.cpp b/lib/Transforms/TransformInternals.cpp index 8cd2511..b6739f4 100644 --- a/lib/Transforms/TransformInternals.cpp +++ b/lib/Transforms/TransformInternals.cpp @@ -34,7 +34,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... - Indices.push_back(ConstantUInt::get(Type::UIntTy, i)); + Indices.push_back(ConstantInt::get(Type::UIntTy, i)); Offset = SL->MemberOffsets[i]; return STy->getContainedType(i); } @@ -73,10 +73,11 @@ const Type *llvm::getStructOffsetType(const Type *Ty, unsigned &Offset, NextType = ATy->getElementType(); unsigned ChildSize = (unsigned)TD.getTypeSize(NextType); - if (ConstantSInt::isValueValidForType(Type::IntTy, Offset/ChildSize)) - Indices.push_back(ConstantSInt::get(Type::IntTy, Offset/ChildSize)); + if (ConstantInt::isValueValidForType(Type::IntTy, + uint64_t(Offset/ChildSize))) + Indices.push_back(ConstantInt::get(Type::IntTy, Offset/ChildSize)); else - Indices.push_back(ConstantSInt::get(Type::LongTy, Offset/ChildSize)); + Indices.push_back(ConstantInt::get(Type::LongTy, Offset/ChildSize)); ThisOffset = (Offset/ChildSize)*ChildSize; } else { Offset = 0; // Return the offset that we were able to achieve diff --git a/lib/Transforms/TransformInternals.h b/lib/Transforms/TransformInternals.h index 51e32c8..4e28904 100644 --- a/lib/Transforms/TransformInternals.h +++ b/lib/Transforms/TransformInternals.h @@ -25,7 +25,7 @@ namespace llvm { static inline int64_t getConstantValue(const ConstantInt *CPI) { - return (int64_t)cast<ConstantInt>(CPI)->getRawValue(); + return (int64_t)cast<ConstantInt>(CPI)->getZExtValue(); } diff --git a/lib/Transforms/Utils/CodeExtractor.cpp b/lib/Transforms/Utils/CodeExtractor.cpp index f264cff..ba40345 100644 --- a/lib/Transforms/Utils/CodeExtractor.cpp +++ b/lib/Transforms/Utils/CodeExtractor.cpp @@ -305,7 +305,7 @@ Function *CodeExtractor::constructFunction(const Values &inputs, if (AggregateArgs) { std::vector<Value*> Indices; Indices.push_back(Constant::getNullValue(Type::UIntTy)); - Indices.push_back(ConstantUInt::get(Type::UIntTy, i)); + Indices.push_back(ConstantInt::get(Type::UIntTy, i)); std::string GEPname = "gep_" + inputs[i]->getName(); TerminatorInst *TI = newFunction->begin()->getTerminator(); GetElementPtrInst *GEP = new GetElementPtrInst(AI, Indices, GEPname, TI); @@ -392,7 +392,7 @@ emitCallAndSwitchStatement(Function *newFunction, BasicBlock *codeReplacer, for (unsigned i = 0, e = inputs.size(); i != e; ++i) { std::vector<Value*> Indices; Indices.push_back(Constant::getNullValue(Type::UIntTy)); - Indices.push_back(ConstantUInt::get(Type::UIntTy, i)); + Indices.push_back(ConstantInt::get(Type::UIntTy, i)); GetElementPtrInst *GEP = new GetElementPtrInst(Struct, Indices, "gep_" + StructValues[i]->getName()); @@ -418,7 +418,7 @@ emitCallAndSwitchStatement(Function *newFunction, BasicBlock *codeReplacer, if (AggregateArgs) { std::vector<Value*> Indices; Indices.push_back(Constant::getNullValue(Type::UIntTy)); - Indices.push_back(ConstantUInt::get(Type::UIntTy, FirstOut + i)); + Indices.push_back(ConstantInt::get(Type::UIntTy, FirstOut + i)); GetElementPtrInst *GEP = new GetElementPtrInst(Struct, Indices, "gep_reload_" + outputs[i]->getName()); @@ -439,7 +439,7 @@ emitCallAndSwitchStatement(Function *newFunction, BasicBlock *codeReplacer, // Now we can emit a switch statement using the call as a value. SwitchInst *TheSwitch = - new SwitchInst(ConstantUInt::getNullValue(Type::UShortTy), + new SwitchInst(ConstantInt::getNullValue(Type::UShortTy), codeReplacer, 0, codeReplacer); // Since there may be multiple exits from the original region, make the new @@ -473,14 +473,14 @@ emitCallAndSwitchStatement(Function *newFunction, BasicBlock *codeReplacer, brVal = ConstantBool::get(!SuccNum); break; default: - brVal = ConstantUInt::get(Type::UShortTy, SuccNum); + brVal = ConstantInt::get(Type::UShortTy, SuccNum); break; } ReturnInst *NTRet = new ReturnInst(brVal, NewTarget); // Update the switch instruction. - TheSwitch->addCase(ConstantUInt::get(Type::UShortTy, SuccNum), + TheSwitch->addCase(ConstantInt::get(Type::UShortTy, SuccNum), OldTarget); // Restore values just before we exit @@ -519,7 +519,7 @@ emitCallAndSwitchStatement(Function *newFunction, BasicBlock *codeReplacer, if (AggregateArgs) { std::vector<Value*> Indices; Indices.push_back(Constant::getNullValue(Type::UIntTy)); - Indices.push_back(ConstantUInt::get(Type::UIntTy,FirstOut+out)); + Indices.push_back(ConstantInt::get(Type::UIntTy,FirstOut+out)); GetElementPtrInst *GEP = new GetElementPtrInst(OAI, Indices, "gep_" + outputs[out]->getName(), diff --git a/lib/Transforms/Utils/Local.cpp b/lib/Transforms/Utils/Local.cpp index 3d1faff..28864fd 100644 --- a/lib/Transforms/Utils/Local.cpp +++ b/lib/Transforms/Utils/Local.cpp @@ -272,10 +272,10 @@ Constant *llvm::ConstantFoldLoadThroughGEPConstantExpr(Constant *C, gep_type_iterator I = gep_type_begin(CE), E = gep_type_end(CE); for (++I; I != E; ++I) if (const StructType *STy = dyn_cast<StructType>(*I)) { - ConstantUInt *CU = cast<ConstantUInt>(I.getOperand()); - assert(CU->getValue() < STy->getNumElements() && + ConstantInt *CU = cast<ConstantInt>(I.getOperand()); + assert(CU->getZExtValue() < STy->getNumElements() && "Struct index out of range!"); - unsigned El = (unsigned)CU->getValue(); + unsigned El = (unsigned)CU->getZExtValue(); if (ConstantStruct *CS = dyn_cast<ConstantStruct>(C)) { C = CS->getOperand(El); } else if (isa<ConstantAggregateZero>(C)) { @@ -287,10 +287,10 @@ Constant *llvm::ConstantFoldLoadThroughGEPConstantExpr(Constant *C, } } else if (ConstantInt *CI = dyn_cast<ConstantInt>(I.getOperand())) { if (const ArrayType *ATy = dyn_cast<ArrayType>(*I)) { - if ((uint64_t)CI->getRawValue() >= ATy->getNumElements()) + if (CI->getZExtValue() >= ATy->getNumElements()) return 0; if (ConstantArray *CA = dyn_cast<ConstantArray>(C)) - C = CA->getOperand((unsigned)CI->getRawValue()); + C = CA->getOperand(CI->getZExtValue()); else if (isa<ConstantAggregateZero>(C)) C = Constant::getNullValue(ATy->getElementType()); else if (isa<UndefValue>(C)) @@ -298,10 +298,10 @@ Constant *llvm::ConstantFoldLoadThroughGEPConstantExpr(Constant *C, else return 0; } else if (const PackedType *PTy = dyn_cast<PackedType>(*I)) { - if ((uint64_t)CI->getRawValue() >= PTy->getNumElements()) + if (CI->getZExtValue() >= PTy->getNumElements()) return 0; if (ConstantPacked *CP = dyn_cast<ConstantPacked>(C)) - C = CP->getOperand((unsigned)CI->getRawValue()); + C = CP->getOperand(CI->getZExtValue()); else if (isa<ConstantAggregateZero>(C)) C = Constant::getNullValue(PTy->getElementType()); else if (isa<UndefValue>(C)) diff --git a/lib/Transforms/Utils/LowerAllocations.cpp b/lib/Transforms/Utils/LowerAllocations.cpp index 451df70..d08235c 100644 --- a/lib/Transforms/Utils/LowerAllocations.cpp +++ b/lib/Transforms/Utils/LowerAllocations.cpp @@ -119,14 +119,14 @@ bool LowerAllocations::runOnBasicBlock(BasicBlock &BB) { // malloc(type) becomes sbyte *malloc(size) Value *MallocArg; if (LowerMallocArgToInteger) - MallocArg = ConstantUInt::get(Type::ULongTy, TD.getTypeSize(AllocTy)); + MallocArg = ConstantInt::get(Type::ULongTy, TD.getTypeSize(AllocTy)); else MallocArg = ConstantExpr::getSizeOf(AllocTy); MallocArg = ConstantExpr::getCast(cast<Constant>(MallocArg), IntPtrTy); if (MI->isArrayAllocation()) { if (isa<ConstantInt>(MallocArg) && - cast<ConstantInt>(MallocArg)->getRawValue() == 1) { + cast<ConstantInt>(MallocArg)->getZExtValue() == 1) { MallocArg = MI->getOperand(0); // Operand * 1 = Operand } else if (Constant *CO = dyn_cast<Constant>(MI->getOperand(0))) { CO = ConstantExpr::getCast(CO, IntPtrTy); diff --git a/lib/Transforms/Utils/LowerInvoke.cpp b/lib/Transforms/Utils/LowerInvoke.cpp index 9180557..1816144 100644 --- a/lib/Transforms/Utils/LowerInvoke.cpp +++ b/lib/Transforms/Utils/LowerInvoke.cpp @@ -269,7 +269,7 @@ bool LowerInvoke::insertCheapEHSupport(Function &F) { void LowerInvoke::rewriteExpensiveInvoke(InvokeInst *II, unsigned InvokeNo, AllocaInst *InvokeNum, SwitchInst *CatchSwitch) { - ConstantUInt *InvokeNoC = ConstantUInt::get(Type::UIntTy, InvokeNo); + ConstantInt *InvokeNoC = ConstantInt::get(Type::UIntTy, InvokeNo); // Insert a store of the invoke num before the invoke and store zero into the // location afterward. @@ -461,7 +461,7 @@ bool LowerInvoke::insertExpensiveEHSupport(Function &F) { std::vector<Value*> Idx; Idx.push_back(Constant::getNullValue(Type::IntTy)); - Idx.push_back(ConstantUInt::get(Type::UIntTy, 1)); + Idx.push_back(ConstantInt::get(Type::UIntTy, 1)); OldJmpBufPtr = new GetElementPtrInst(JmpBuf, Idx, "OldBuf", EntryBB->getTerminator()); @@ -500,7 +500,7 @@ bool LowerInvoke::insertExpensiveEHSupport(Function &F) { BasicBlock *ContBlock = EntryBB->splitBasicBlock(EntryBB->getTerminator(), "setjmp.cont"); - Idx[1] = ConstantUInt::get(Type::UIntTy, 0); + Idx[1] = ConstantInt::get(Type::UIntTy, 0); Value *JmpBufPtr = new GetElementPtrInst(JmpBuf, Idx, "TheJmpBuf", EntryBB->getTerminator()); Value *SJRet = new CallInst(SetJmpFn, JmpBufPtr, "sjret", @@ -550,7 +550,7 @@ bool LowerInvoke::insertExpensiveEHSupport(Function &F) { // Get a pointer to the jmpbuf and longjmp. std::vector<Value*> Idx; Idx.push_back(Constant::getNullValue(Type::IntTy)); - Idx.push_back(ConstantUInt::get(Type::UIntTy, 0)); + Idx.push_back(ConstantInt::get(Type::UIntTy, 0)); Idx[0] = new GetElementPtrInst(BufPtr, Idx, "JmpBuf", UnwindBlock); Idx[1] = ConstantInt::get(Type::IntTy, 1); new CallInst(LongJmpFn, Idx, "", UnwindBlock); diff --git a/lib/Transforms/Utils/LowerSwitch.cpp b/lib/Transforms/Utils/LowerSwitch.cpp index 12a32f1..724499d 100644 --- a/lib/Transforms/Utils/LowerSwitch.cpp +++ b/lib/Transforms/Utils/LowerSwitch.cpp @@ -60,11 +60,12 @@ namespace { struct CaseCmp { bool operator () (const LowerSwitch::Case& C1, const LowerSwitch::Case& C2) { - if (const ConstantUInt* U1 = dyn_cast<const ConstantUInt>(C1.first)) - return U1->getValue() < cast<const ConstantUInt>(C2.first)->getValue(); - const ConstantSInt* S1 = dyn_cast<const ConstantSInt>(C1.first); - return S1->getValue() < cast<const ConstantSInt>(C2.first)->getValue(); + const ConstantInt* CI1 = cast<const ConstantInt>(C1.first); + const ConstantInt* CI2 = cast<const ConstantInt>(C2.first); + if (CI1->getType()->isUnsigned()) + return CI1->getZExtValue() < CI2->getZExtValue(); + return CI1->getSExtValue() < CI2->getSExtValue(); } }; @@ -129,7 +130,7 @@ BasicBlock* LowerSwitch::switchConvert(CaseItr Begin, CaseItr End, Case& Pivot = *(Begin + Mid); DEBUG(std::cerr << "Pivot ==> " - << (int64_t)cast<ConstantInt>(Pivot.first)->getRawValue() + << cast<ConstantInt>(Pivot.first)->getSExtValue() << "\n"); BasicBlock* LBranch = switchConvert(LHS.begin(), LHS.end(), Val, diff --git a/lib/Transforms/Utils/SimplifyCFG.cpp b/lib/Transforms/Utils/SimplifyCFG.cpp index 867455e..de2ab06 100644 --- a/lib/Transforms/Utils/SimplifyCFG.cpp +++ b/lib/Transforms/Utils/SimplifyCFG.cpp @@ -1160,7 +1160,7 @@ namespace { /// applications that sort ConstantInt's to ensure uniqueness. struct ConstantIntOrdering { bool operator()(const ConstantInt *LHS, const ConstantInt *RHS) const { - return LHS->getRawValue() < RHS->getRawValue(); + return LHS->getZExtValue() < RHS->getZExtValue(); } }; } |