diff options
author | Misha Brukman <brukman+llvm@gmail.com> | 2005-04-21 23:48:37 +0000 |
---|---|---|
committer | Misha Brukman <brukman+llvm@gmail.com> | 2005-04-21 23:48:37 +0000 |
commit | fd93908ae8b9684fe71c239e3c6cfe13ff6a2663 (patch) | |
tree | 4d0726d997a629d08765d11a705a42c4f48690af | |
parent | 0e0a7a45d3d0a8c865a078459d2e1c6d8967a100 (diff) | |
download | external_llvm-fd93908ae8b9684fe71c239e3c6cfe13ff6a2663.zip external_llvm-fd93908ae8b9684fe71c239e3c6cfe13ff6a2663.tar.gz external_llvm-fd93908ae8b9684fe71c239e3c6cfe13ff6a2663.tar.bz2 |
Remove trailing whitespace
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21427 91177308-0d34-0410-b5e6-96231b3b80d8
126 files changed, 1880 insertions, 1880 deletions
diff --git a/lib/Analysis/ConstantRange.cpp b/lib/Analysis/ConstantRange.cpp index 3b91c5b..109ed42 100644 --- a/lib/Analysis/ConstantRange.cpp +++ b/lib/Analysis/ConstantRange.cpp @@ -1,10 +1,10 @@ //===-- ConstantRange.cpp - ConstantRange implementation ------------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // Represent a range of possible values that may occur when the program is run @@ -32,7 +32,7 @@ using namespace llvm; static ConstantIntegral *Next(ConstantIntegral *CI) { if (CI->getType() == Type::BoolTy) return CI == ConstantBool::True ? ConstantBool::False : ConstantBool::True; - + Constant *Result = ConstantExpr::getAdd(CI, ConstantInt::get(CI->getType(), 1)); return cast<ConstantIntegral>(Result); @@ -84,7 +84,7 @@ ConstantRange::ConstantRange(Constant *L, Constant *U) : Lower(cast<ConstantIntegral>(L)), Upper(cast<ConstantIntegral>(U)) { assert(Lower->getType() == Upper->getType() && "Incompatible types for ConstantRange!"); - + // Make sure that if L & U are equal that they are either Min or Max... assert((L != U || (L == ConstantIntegral::getMaxValue(L->getType()) || L == ConstantIntegral::getMinValue(L->getType()))) && @@ -126,7 +126,7 @@ const Type *ConstantRange::getType() const { return Lower->getType(); } bool ConstantRange::isFullSet() const { return Lower == Upper && Lower == ConstantIntegral::getMaxValue(getType()); } - + /// isEmptySet - Return true if this set contains no members. /// bool ConstantRange::isEmptySet() const { @@ -140,7 +140,7 @@ bool ConstantRange::isWrappedSet() const { return GT(Lower, Upper); } - + /// getSingleElement - If this set contains a single element, return it, /// otherwise return null. ConstantIntegral *ConstantRange::getSingleElement() const { @@ -158,7 +158,7 @@ uint64_t ConstantRange::getSetSize() const { return 1; return 2; // Must be full set... } - + // Simply subtract the bounds... Constant *Result = ConstantExpr::getSub(Upper, Lower); return cast<ConstantInt>(Result)->getRawValue(); diff --git a/lib/Support/ConstantRange.cpp b/lib/Support/ConstantRange.cpp index 3b91c5b..109ed42 100644 --- a/lib/Support/ConstantRange.cpp +++ b/lib/Support/ConstantRange.cpp @@ -1,10 +1,10 @@ //===-- ConstantRange.cpp - ConstantRange implementation ------------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // Represent a range of possible values that may occur when the program is run @@ -32,7 +32,7 @@ using namespace llvm; static ConstantIntegral *Next(ConstantIntegral *CI) { if (CI->getType() == Type::BoolTy) return CI == ConstantBool::True ? ConstantBool::False : ConstantBool::True; - + Constant *Result = ConstantExpr::getAdd(CI, ConstantInt::get(CI->getType(), 1)); return cast<ConstantIntegral>(Result); @@ -84,7 +84,7 @@ ConstantRange::ConstantRange(Constant *L, Constant *U) : Lower(cast<ConstantIntegral>(L)), Upper(cast<ConstantIntegral>(U)) { assert(Lower->getType() == Upper->getType() && "Incompatible types for ConstantRange!"); - + // Make sure that if L & U are equal that they are either Min or Max... assert((L != U || (L == ConstantIntegral::getMaxValue(L->getType()) || L == ConstantIntegral::getMinValue(L->getType()))) && @@ -126,7 +126,7 @@ const Type *ConstantRange::getType() const { return Lower->getType(); } bool ConstantRange::isFullSet() const { return Lower == Upper && Lower == ConstantIntegral::getMaxValue(getType()); } - + /// isEmptySet - Return true if this set contains no members. /// bool ConstantRange::isEmptySet() const { @@ -140,7 +140,7 @@ bool ConstantRange::isWrappedSet() const { return GT(Lower, Upper); } - + /// getSingleElement - If this set contains a single element, return it, /// otherwise return null. ConstantIntegral *ConstantRange::getSingleElement() const { @@ -158,7 +158,7 @@ uint64_t ConstantRange::getSetSize() const { return 1; return 2; // Must be full set... } - + // Simply subtract the bounds... Constant *Result = ConstantExpr::getSub(Upper, Lower); return cast<ConstantInt>(Result)->getRawValue(); diff --git a/lib/Transforms/ExprTypeConvert.cpp b/lib/Transforms/ExprTypeConvert.cpp index 0389daa..f43390d 100644 --- a/lib/Transforms/ExprTypeConvert.cpp +++ b/lib/Transforms/ExprTypeConvert.cpp @@ -1,10 +1,10 @@ //===- ExprTypeConvert.cpp - Code to change an LLVM Expr Type -------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements the part of level raising that checks to see if it is @@ -69,7 +69,7 @@ static bool MallocConvertibleToType(MallocInst *MI, const Type *Ty, // here... uint64_t Offset = OffsetVal * OldTypeSize; uint64_t Scale = ScaleVal * OldTypeSize; - + // In order to be successful, both the scale and the offset must be a multiple // of the requested data type's size. // @@ -145,7 +145,7 @@ bool llvm::ExpressionConvertibleToType(Value *V, const Type *Ty, // Expression type must be holdable in a register. if (!Ty->isFirstClassType()) return false; - + ValueTypeCache::iterator CTMI = CTMap.find(V); if (CTMI != CTMap.end()) return CTMI->second == Ty; @@ -154,7 +154,7 @@ bool llvm::ExpressionConvertibleToType(Value *V, const Type *Ty, // if (isa<Constant>(V) && !isa<GlobalValue>(V)) return true; - + CTMap[V] = Ty; if (V->getType() == Ty) return true; // Expression already correct type! @@ -170,7 +170,7 @@ bool llvm::ExpressionConvertibleToType(Value *V, const Type *Ty, // We also do not allow conversion of a cast that casts from a ptr to array // of X to a *X. For example: cast [4 x %List *] * %val to %List * * // - if (const PointerType *SPT = + if (const PointerType *SPT = dyn_cast<PointerType>(I->getOperand(0)->getType())) if (const PointerType *DPT = dyn_cast<PointerType>(I->getType())) if (const ArrayType *AT = dyn_cast<ArrayType>(SPT->getElementType())) @@ -200,7 +200,7 @@ bool llvm::ExpressionConvertibleToType(Value *V, const Type *Ty, if (!ExpressionConvertibleToType(LI->getPointerOperand(), PointerType::get(Ty), CTMap, TD)) return false; - break; + break; } case Instruction::PHI: { PHINode *PN = cast<PHINode>(I); @@ -227,7 +227,7 @@ bool llvm::ExpressionConvertibleToType(Value *V, const Type *Ty, // %t2 = cast %List * * %t1 to %List * // into // %t2 = getelementptr %Hosp * %hosp, ubyte 4 ; <%List *> - // + // GetElementPtrInst *GEP = cast<GetElementPtrInst>(I); const PointerType *PTy = dyn_cast<PointerType>(Ty); if (!PTy) return false; // GEP must always return a pointer... @@ -283,9 +283,9 @@ bool llvm::ExpressionConvertibleToType(Value *V, const Type *Ty, // and want to convert it into something like this: // getelemenptr [[int] *] * %reg115, long %reg138 ; [int]** // - if (GEP->getNumOperands() == 2 && + if (GEP->getNumOperands() == 2 && PTy->getElementType()->isSized() && - TD.getTypeSize(PTy->getElementType()) == + TD.getTypeSize(PTy->getElementType()) == TD.getTypeSize(GEP->getType()->getElementType())) { const PointerType *NewSrcTy = PointerType::get(PVTy); if (!ExpressionConvertibleToType(I->getOperand(0), NewSrcTy, CTMap, TD)) @@ -329,7 +329,7 @@ bool llvm::ExpressionConvertibleToType(Value *V, const Type *Ty, } -Value *llvm::ConvertExpressionToType(Value *V, const Type *Ty, +Value *llvm::ConvertExpressionToType(Value *V, const Type *Ty, ValueMapCache &VMC, const TargetData &TD) { if (V->getType() == Ty) return V; // Already where we need to be? @@ -364,7 +364,7 @@ Value *llvm::ConvertExpressionToType(Value *V, const Type *Ty, Instruction *Res; // Result of conversion ValueHandle IHandle(VMC, I); // Prevent I from being removed! - + Constant *Dummy = Constant::getNullValue(Ty); switch (I->getOpcode()) { @@ -373,7 +373,7 @@ Value *llvm::ConvertExpressionToType(Value *V, const Type *Ty, Res = new CastInst(I->getOperand(0), Ty, Name); VMC.NewCasts.insert(ValueHandle(VMC, Res)); break; - + case Instruction::Add: case Instruction::Sub: Res = BinaryOperator::create(cast<BinaryOperator>(I)->getOpcode(), @@ -436,7 +436,7 @@ Value *llvm::ConvertExpressionToType(Value *V, const Type *Ty, // %t2 = cast %List * * %t1 to %List * // into // %t2 = getelementptr %Hosp * %hosp, ubyte 4 ; <%List *> - // + // GetElementPtrInst *GEP = cast<GetElementPtrInst>(I); // Check to see if there are zero elements that we can remove from the @@ -461,7 +461,7 @@ Value *llvm::ConvertExpressionToType(Value *V, const Type *Ty, if (Res == 0 && GEP->getNumOperands() == 2 && GEP->getType() == PointerType::get(Type::SByteTy)) { - + // Otherwise, we can convert a GEP from one form to the other iff the // current gep is of the form 'getelementptr sbyte*, unsigned N // and we could convert this to an appropriate GEP for the new type. @@ -475,7 +475,7 @@ Value *llvm::ConvertExpressionToType(Value *V, const Type *Ty, std::vector<Value*> Indices; const Type *ElTy = ConvertibleToGEP(NewSrcTy, I->getOperand(1), Indices, TD, &It); - if (ElTy) { + if (ElTy) { assert(ElTy == PVTy && "Internal error, setup wrong!"); Res = new GetElementPtrInst(Constant::getNullValue(NewSrcTy), Indices, Name); @@ -625,7 +625,7 @@ static bool OperandConvertibleToType(User *U, Value *V, const Type *Ty, // We also do not allow conversion of a cast that casts from a ptr to array // of X to a *X. For example: cast [4 x %List *] * %val to %List * * // - if (const PointerType *SPT = + if (const PointerType *SPT = dyn_cast<PointerType>(I->getOperand(0)->getType())) if (const PointerType *DPT = dyn_cast<PointerType>(I->getType())) if (const ArrayType *AT = dyn_cast<ArrayType>(SPT->getElementType())) @@ -645,7 +645,7 @@ static bool OperandConvertibleToType(User *U, Value *V, const Type *Ty, CTMap[I] = RetTy; return true; } - // We have to return failure here because ValueConvertibleToType could + // We have to return failure here because ValueConvertibleToType could // have polluted our map return false; } @@ -681,7 +681,7 @@ static bool OperandConvertibleToType(User *U, Value *V, const Type *Ty, if (const PointerType *PT = dyn_cast<PointerType>(Ty)) { LoadInst *LI = cast<LoadInst>(I); - + const Type *LoadedTy = PT->getElementType(); // They could be loading the first element of a composite type... @@ -733,7 +733,7 @@ static bool OperandConvertibleToType(User *U, Value *V, const Type *Ty, assert(Offset == 0 && "Offset changed!"); if (ElTy == 0) // Element at offset zero in struct doesn't exist! return false; // Can only happen for {}* - + if (ElTy == Ty) // Looks like the 0th element of structure is return true; // compatible! Accept now! @@ -763,7 +763,7 @@ static bool OperandConvertibleToType(User *U, Value *V, const Type *Ty, } // Must move the same amount of data... - if (!ElTy->isSized() || + if (!ElTy->isSized() || TD.getTypeSize(ElTy) != TD.getTypeSize(I->getOperand(0)->getType())) return false; @@ -801,7 +801,7 @@ static bool OperandConvertibleToType(User *U, Value *V, const Type *Ty, CST = ConstantSInt::get(Index->getType(), DataSize); else CST = ConstantUInt::get(Index->getType(), DataSize); - + TempScale = BinaryOperator::create(Instruction::Mul, Index, CST); Index = TempScale; } @@ -854,7 +854,7 @@ static bool OperandConvertibleToType(User *U, Value *V, const Type *Ty, // the call provides... // if (NumArgs < FTy->getNumParams()) return false; - + // Unless this is a vararg function type, we cannot provide more arguments // than are desired... // @@ -878,7 +878,7 @@ static bool OperandConvertibleToType(User *U, Value *V, const Type *Ty, // return ValueConvertibleToType(I, FTy->getReturnType(), CTMap, TD); } - + const PointerType *MPtr = cast<PointerType>(I->getOperand(0)->getType()); const FunctionType *FTy = cast<FunctionType>(MPtr->getElementType()); if (!FTy->isVarArg()) return false; @@ -941,7 +941,7 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, ValueHandle IHandle(VMC, I); const Type *NewTy = NewVal->getType(); - Constant *Dummy = (NewTy != Type::VoidTy) ? + Constant *Dummy = (NewTy != Type::VoidTy) ? Constant::getNullValue(NewTy) : 0; switch (I->getOpcode()) { @@ -1025,7 +1025,7 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, Src = new GetElementPtrInst(Src, Indices, Name+".idx", I); } } - + Res = new LoadInst(Src, Name); assert(Res->getType()->isFirstClassType() && "Load of structure or array!"); break; @@ -1042,13 +1042,13 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, // const Type *ElTy = cast<PointerType>(VMCI->second->getType())->getElementType(); - + Value *SrcPtr = VMCI->second; if (ElTy != NewTy) { // We check that this is a struct in the initial scan... const StructType *SElTy = cast<StructType>(ElTy); - + std::vector<Value*> Indices; Indices.push_back(Constant::getNullValue(Type::UIntTy)); @@ -1135,7 +1135,7 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, // anything that is a pointer type... // BasicBlock::iterator It = I; - + // Check to see if the second argument is an expression that can // be converted to the appropriate size... if so, allow it. // @@ -1143,7 +1143,7 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, const Type *ElTy = ConvertibleToGEP(NewVal->getType(), I->getOperand(1), Indices, TD, &It); assert(ElTy != 0 && "GEP Conversion Failure!"); - + Res = new GetElementPtrInst(NewVal, Indices, Name); } else { // Convert a getelementptr ulong * %reg123, uint %N @@ -1271,7 +1271,7 @@ static void RecursiveDelete(ValueMapCache &Cache, Instruction *I) { //DEBUG(std::cerr << "VH DELETING: " << (void*)I << " " << I); - for (User::op_iterator OI = I->op_begin(), OE = I->op_end(); + for (User::op_iterator OI = I->op_begin(), OE = I->op_end(); OI != OE; ++OI) if (Instruction *U = dyn_cast<Instruction>(OI)) { *OI = 0; diff --git a/lib/Transforms/Hello/Hello.cpp b/lib/Transforms/Hello/Hello.cpp index 36a60fa..b7fc870 100644 --- a/lib/Transforms/Hello/Hello.cpp +++ b/lib/Transforms/Hello/Hello.cpp @@ -1,10 +1,10 @@ //===- Hello.cpp - Example code from "Writing an LLVM Pass" ---------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements two versions of the LLVM "Hello World" pass described @@ -24,7 +24,7 @@ namespace { std::cerr << "Hello: " << F.getName() << "\n"; return false; } - }; + }; RegisterOpt<Hello> X("hello", "Hello World Pass"); // Hello2 - The second implementation with getAnalysisUsage implemented. @@ -38,6 +38,6 @@ namespace { virtual void getAnalysisUsage(AnalysisUsage &AU) const { AU.setPreservesAll(); }; - }; + }; RegisterOpt<Hello2> Y("hello2", "Hello World Pass (with getAnalysisUsage implemented)"); } diff --git a/lib/Transforms/IPO/ArgumentPromotion.cpp b/lib/Transforms/IPO/ArgumentPromotion.cpp index 87a8f02..028fda9 100644 --- a/lib/Transforms/IPO/ArgumentPromotion.cpp +++ b/lib/Transforms/IPO/ArgumentPromotion.cpp @@ -1,10 +1,10 @@ //===-- ArgumentPromotion.cpp - Promote by-reference arguments ------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This pass promotes "by reference" arguments to be "by value" arguments. In @@ -67,7 +67,7 @@ namespace { virtual bool runOnSCC(const std::vector<CallGraphNode *> &SCC); private: bool PromoteArguments(CallGraphNode *CGN); - bool isSafeToPromoteArgument(Argument *Arg) const; + bool isSafeToPromoteArgument(Argument *Arg) const; Function *DoPromotion(Function *F, std::vector<Argument*> &ArgsToPromote); }; @@ -89,7 +89,7 @@ bool ArgPromotion::runOnSCC(const std::vector<CallGraphNode *> &SCC) { LocalChange |= PromoteArguments(SCC[i]); Changed |= LocalChange; // Remember that we changed something. } while (LocalChange); - + return Changed; } @@ -306,7 +306,7 @@ namespace { unsigned idx = 0; for (; idx < LHS.size() && idx < RHS.size(); ++idx) { if (LHS[idx] != RHS[idx]) { - return cast<ConstantInt>(LHS[idx])->getRawValue() < + return cast<ConstantInt>(LHS[idx])->getRawValue() < cast<ConstantInt>(RHS[idx])->getRawValue(); } } @@ -325,7 +325,7 @@ namespace { Function *ArgPromotion::DoPromotion(Function *F, std::vector<Argument*> &Args2Prom) { std::set<Argument*> ArgsToPromote(Args2Prom.begin(), Args2Prom.end()); - + // Start by computing a new prototype for the function, which is the same as // the old function, but has modified arguments. const FunctionType *FTy = F->getFunctionType(); @@ -391,7 +391,7 @@ Function *ArgPromotion::DoPromotion(Function *F, Params.push_back(Type::IntTy); } FunctionType *NFTy = FunctionType::get(RetTy, Params, FTy->isVarArg()); - + // Create the new function body and insert it into the module... Function *NF = new Function(NFTy, F->getLinkage(), F->getName()); F->getParent()->getFunctionList().insert(F, NF); @@ -456,7 +456,7 @@ Function *ArgPromotion::DoPromotion(Function *F, Call->setName(""); New->setName(Name); } - + // Finally, remove the old call from the program, reducing the use-count of // F. Call->getParent()->getInstList().erase(Call); diff --git a/lib/Transforms/IPO/ConstantMerge.cpp b/lib/Transforms/IPO/ConstantMerge.cpp index 0140228..b6026f2 100644 --- a/lib/Transforms/IPO/ConstantMerge.cpp +++ b/lib/Transforms/IPO/ConstantMerge.cpp @@ -1,10 +1,10 @@ //===- ConstantMerge.cpp - Merge duplicate global constants ---------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file defines the interface to a pass that merges duplicate global @@ -60,10 +60,10 @@ bool ConstantMerge::runOnModule(Module &M) { // Only process constants with initializers if (GV->isConstant() && GV->hasInitializer()) { Constant *Init = GV->getInitializer(); - + // Check to see if the initializer is already known... std::map<Constant*, GlobalVariable*>::iterator I = CMap.find(Init); - + if (I == CMap.end()) { // Nope, add it to the map CMap.insert(I, std::make_pair(Init, GV)); } else if (GV->hasInternalLinkage()) { // Yup, this is a duplicate! @@ -75,22 +75,22 @@ bool ConstantMerge::runOnModule(Module &M) { I->second = GV; } } - + if (Replacements.empty()) return MadeChange; CMap.clear(); - + // Now that we have figured out which replacements must be made, do them all // now. This avoid invalidating the pointers in CMap, which are unneeded // now. for (unsigned i = 0, e = Replacements.size(); i != e; ++i) { // Eliminate any uses of the dead global... Replacements[i].first->replaceAllUsesWith(Replacements[i].second); - + // Delete the global value from the module... M.getGlobalList().erase(Replacements[i].first); } - + NumMerged += Replacements.size(); Replacements.clear(); } diff --git a/lib/Transforms/IPO/DeadArgumentElimination.cpp b/lib/Transforms/IPO/DeadArgumentElimination.cpp index e226dc3..d1b548a 100644 --- a/lib/Transforms/IPO/DeadArgumentElimination.cpp +++ b/lib/Transforms/IPO/DeadArgumentElimination.cpp @@ -1,10 +1,10 @@ //===-- DeadArgumentElimination.cpp - Eliminate dead arguments ------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This pass deletes dead arguments from internal functions. Dead argument @@ -88,7 +88,7 @@ namespace { void MarkArgumentLive(Argument *Arg); void MarkRetValLive(Function *F); void MarkReturnInstArgumentLive(ReturnInst *RI); - + void RemoveDeadArgumentsFromFunction(Function *F); }; RegisterOpt<DAE> X("deadargelim", "Dead Argument Elimination"); @@ -168,7 +168,7 @@ void DAE::SurveyFunction(Function &F) { if (!F.hasInternalLinkage() && (!ShouldHackArguments() || F.getIntrinsicID())) FunctionIntrinsicallyLive = true; - else + else for (Value::use_iterator I = F.use_begin(), E = F.use_end(); I != E; ++I) { // If this use is anything other than a call site, the function is alive. CallSite CS = CallSite::get(*I); @@ -197,7 +197,7 @@ void DAE::SurveyFunction(Function &F) { RetValLiveness = Live; break; } - + // If the function is PASSED IN as an argument, its address has been taken for (CallSite::arg_iterator AI = CS.arg_begin(), E = CS.arg_end(); AI != E; ++AI) @@ -300,11 +300,11 @@ bool DAE::isMaybeLiveArgumentNowLive(Argument *Arg) { void DAE::MarkArgumentLive(Argument *Arg) { std::set<Argument*>::iterator It = MaybeLiveArguments.lower_bound(Arg); if (It == MaybeLiveArguments.end() || *It != Arg) return; - + DEBUG(std::cerr << " MaybeLive argument now live: " << Arg->getName()<<"\n"); MaybeLiveArguments.erase(It); LiveArguments.insert(Arg); - + // Loop over all of the call sites of the function, making any arguments // passed in to provide a value for this argument live as necessary. // @@ -440,7 +440,7 @@ void DAE::RemoveDeadArgumentsFromFunction(Function *F) { New->setName(Name); } } - + // Finally, remove the old call from the program, reducing the use-count of // F. Call->getParent()->getInstList().erase(Call); @@ -499,7 +499,7 @@ bool DAE::runOnModule(Module &M) { while (!InstructionsToInspect.empty()) { Instruction *I = InstructionsToInspect.back(); InstructionsToInspect.pop_back(); - + if (ReturnInst *RI = dyn_cast<ReturnInst>(I)) { // For return instructions, we just have to check to see if the return // value for the current function is known now to be alive. If so, any @@ -513,7 +513,7 @@ bool DAE::runOnModule(Module &M) { assert(CS.getInstruction() && "Unknown instruction for the I2I list!"); Function *Callee = CS.getCalledFunction(); - + // If we found a call or invoke instruction on this list, that means that // an argument of the function is a call instruction. If the argument is // live, then the return value of the called instruction is now live. @@ -556,7 +556,7 @@ bool DAE::runOnModule(Module &M) { if (MaybeLiveArguments.empty() && DeadArguments.empty() && MaybeLiveRetVal.empty() && DeadRetVal.empty()) return false; - + // Otherwise, compact into one set, and start eliminating the arguments from // the functions. DeadArguments.insert(MaybeLiveArguments.begin(), MaybeLiveArguments.end()); diff --git a/lib/Transforms/IPO/DeadTypeElimination.cpp b/lib/Transforms/IPO/DeadTypeElimination.cpp index b3a439e..005d6bd 100644 --- a/lib/Transforms/IPO/DeadTypeElimination.cpp +++ b/lib/Transforms/IPO/DeadTypeElimination.cpp @@ -1,10 +1,10 @@ //===- DeadTypeElimination.cpp - Eliminate unused types for symbol table --===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This pass is used to cleanup the output of GCC. It eliminate names for types diff --git a/lib/Transforms/IPO/ExtractFunction.cpp b/lib/Transforms/IPO/ExtractFunction.cpp index 2d291b7..4cce79b 100644 --- a/lib/Transforms/IPO/ExtractFunction.cpp +++ b/lib/Transforms/IPO/ExtractFunction.cpp @@ -1,10 +1,10 @@ //===-- ExtractFunction.cpp - Function extraction pass --------------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This pass extracts @@ -25,7 +25,7 @@ namespace { /// specified function. Otherwise, it deletes as much of the module as /// possible, except for the function specified. /// - FunctionExtractorPass(Function *F = 0, bool deleteFn = true) + FunctionExtractorPass(Function *F = 0, bool deleteFn = true) : Named(F), deleteFunc(deleteFn) {} bool runOnModule(Module &M) { @@ -36,7 +36,7 @@ namespace { if (deleteFunc) return deleteFunction(); - else + else return isolateFunction(M); } @@ -57,31 +57,31 @@ namespace { I->setInitializer(0); // Make all variables external I->setLinkage(GlobalValue::ExternalLinkage); } - + // All of the functions may be used by global variables or the named // function. Loop through them and create a new, external functions that // can be "used", instead of ones with bodies. std::vector<Function*> NewFunctions; - + Function *Last = --M.end(); // Figure out where the last real fn is. - + for (Module::iterator I = M.begin(); ; ++I) { if (&*I != Named) { Function *New = new Function(I->getFunctionType(), GlobalValue::ExternalLinkage, I->getName()); I->setName(""); // Remove Old name - + // If it's not the named function, delete the body of the function I->dropAllReferences(); - + M.getFunctionList().push_back(New); NewFunctions.push_back(New); } - + if (&*I == Last) break; // Stop after processing the last function } - + // Now that we have replacements all set up, loop through the module, // deleting the old functions, replacing them with the newly created // functions. @@ -92,19 +92,19 @@ namespace { if (&*I != Named) { // Make everything that uses the old function use the new dummy fn I->replaceAllUsesWith(NewFunctions[FuncNum++]); - + Function *Old = I; ++I; // Move the iterator to the new function - + // Delete the old function! M.getFunctionList().erase(Old); - + } else { ++I; // Skip the function we are extracting } } while (&*I != NewFunctions[0]); } - + return true; } }; diff --git a/lib/Transforms/IPO/FunctionResolution.cpp b/lib/Transforms/IPO/FunctionResolution.cpp index dba44a0..8b5019a 100644 --- a/lib/Transforms/IPO/FunctionResolution.cpp +++ b/lib/Transforms/IPO/FunctionResolution.cpp @@ -1,10 +1,10 @@ //===- FunctionResolution.cpp - Resolve declarations to implementations ---===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // Loop over the functions that are in the module and look for functions that @@ -57,7 +57,7 @@ static bool ResolveFunctions(Module &M, std::vector<GlobalValue*> &Globals, Function *Old = cast<Function>(Globals[i]); const FunctionType *OldMT = Old->getFunctionType(); const FunctionType *ConcreteMT = Concrete->getFunctionType(); - + if (OldMT->getNumParams() > ConcreteMT->getNumParams() && !ConcreteMT->isVarArg()) if (!Old->use_empty()) { @@ -69,7 +69,7 @@ static bool ResolveFunctions(Module &M, std::vector<GlobalValue*> &Globals, WriteAsOperand(std::cerr, Concrete); std::cerr << "\n"; } - + // Check to make sure that if there are specified types, that they // match... // @@ -79,7 +79,7 @@ static bool ResolveFunctions(Module &M, std::vector<GlobalValue*> &Globals, if (!Old->use_empty() && !Concrete->use_empty()) for (unsigned i = 0; i < NumArguments; ++i) if (OldMT->getParamType(i) != ConcreteMT->getParamType(i)) - if (OldMT->getParamType(i)->getTypeID() != + if (OldMT->getParamType(i)->getTypeID() != ConcreteMT->getParamType(i)->getTypeID()) { std::cerr << "WARNING: Function [" << Old->getName() << "]: Parameter types conflict for: '"; @@ -89,7 +89,7 @@ static bool ResolveFunctions(Module &M, std::vector<GlobalValue*> &Globals, std::cerr << "'\n"; return Changed; } - + // Attempt to convert all of the uses of the old function to the concrete // form of the function. If there is a use of the fn that we don't // understand here we punt to avoid making a bad transformation. @@ -174,11 +174,11 @@ static bool ProcessGlobalsWithSameName(Module &M, TargetData &TD, if (!F->isExternal()) { if (Concrete && !Concrete->isExternal()) return false; // Found two different functions types. Can't choose! - + Concrete = Globals[i]; } else if (Concrete) { if (Concrete->isExternal()) // If we have multiple external symbols... - if (F->getFunctionType()->getNumParams() > + if (F->getFunctionType()->getNumParams() > cast<Function>(Concrete)->getFunctionType()->getNumParams()) Concrete = F; // We are more concrete than "Concrete"! @@ -213,7 +213,7 @@ static bool ProcessGlobalsWithSameName(Module &M, TargetData &TD, else if (!Globals[i]->hasInternalLinkage()) NumInstancesWithExternalLinkage++; } - + if (!HasExternal && NumInstancesWithExternalLinkage <= 1) return false; // Nothing to do? Must have multiple internal definitions. @@ -231,7 +231,7 @@ static bool ProcessGlobalsWithSameName(Module &M, TargetData &TD, OtherF->getFunctionType()->isVarArg() && OtherF->getFunctionType()->getNumParams() == 0) DontPrintWarning = true; - + // Otherwise, if the non-concrete global is a global array variable with a // size of 0, and the concrete global is an array with a real size, don't // warn. This occurs due to declaring 'extern int A[];'. diff --git a/lib/Transforms/IPO/GlobalDCE.cpp b/lib/Transforms/IPO/GlobalDCE.cpp index b7fa5dc..072cef2 100644 --- a/lib/Transforms/IPO/GlobalDCE.cpp +++ b/lib/Transforms/IPO/GlobalDCE.cpp @@ -1,10 +1,10 @@ //===-- GlobalDCE.cpp - DCE unreachable internal functions ----------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This transform is designed to eliminate unreachable internal globals from the @@ -111,7 +111,7 @@ bool GlobalDCE::runOnModule(Module &M) { NumVariables += DeadGlobalVars.size(); Changed = true; } - + // Make sure that all memory is released AliveGlobals.clear(); return Changed; @@ -148,7 +148,7 @@ void GlobalDCE::GlobalIsNeeded(GlobalValue *G) { if (GlobalValue *GV = dyn_cast<GlobalValue>(*U)) GlobalIsNeeded(GV); else if (Constant *C = dyn_cast<Constant>(*U)) - MarkUsedGlobalsAsNeeded(C); + MarkUsedGlobalsAsNeeded(C); } } @@ -174,7 +174,7 @@ bool GlobalDCE::RemoveUnusedGlobalValue(GlobalValue &GV) { GV.removeDeadConstantUsers(); return GV.use_empty(); } - + // SafeToDestroyConstant - It is safe to destroy a constant iff it is only used // by constants itself. Note that constants cannot be cyclic, so this test is // pretty easy to implement recursively. diff --git a/lib/Transforms/IPO/GlobalOpt.cpp b/lib/Transforms/IPO/GlobalOpt.cpp index 7b6f649..e5bc5b8 100644 --- a/lib/Transforms/IPO/GlobalOpt.cpp +++ b/lib/Transforms/IPO/GlobalOpt.cpp @@ -1,10 +1,10 @@ //===- GlobalOpt.cpp - Optimize Global Variables --------------------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This pass transforms simple global variables that never have their address @@ -47,7 +47,7 @@ namespace { virtual void getAnalysisUsage(AnalysisUsage &AU) const { AU.addRequired<TargetData>(); } - + bool runOnModule(Module &M); private: @@ -201,7 +201,7 @@ static bool AnalyzeGlobal(Value *V, GlobalStatus &GS, // If the first two indices are constants, this can be SRA'd. if (isa<GlobalVariable>(I->getOperand(0))) { if (I->getNumOperands() < 3 || !isa<Constant>(I->getOperand(1)) || - !cast<Constant>(I->getOperand(1))->isNullValue() || + !cast<Constant>(I->getOperand(1))->isNullValue() || !isa<ConstantInt>(I->getOperand(2))) GS.isNotSuitableForSRA = true; } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(I->getOperand(0))){ @@ -304,7 +304,7 @@ static bool CleanupConstantGlobalUsers(Value *V, Constant *Init) { bool Changed = false; for (Value::use_iterator UI = V->use_begin(), E = V->use_end(); UI != E;) { User *U = *UI++; - + if (LoadInst *LI = dyn_cast<LoadInst>(U)) { if (Init) { // Replace the load with the initializer. @@ -367,7 +367,7 @@ static GlobalVariable *SRAGlobal(GlobalVariable *GV) { assert(GV->hasInternalLinkage() && !GV->isConstant()); Constant *Init = GV->getInitializer(); const Type *Ty = Init->getType(); - + std::vector<GlobalVariable*> NewGlobals; Module::GlobalListType &Globals = GV->getParent()->getGlobalList(); @@ -422,7 +422,7 @@ static GlobalVariable *SRAGlobal(GlobalVariable *GV) { assert(((isa<ConstantExpr>(GEP) && cast<ConstantExpr>(GEP)->getOpcode()==Instruction::GetElementPtr)|| isa<GetElementPtrInst>(GEP)) && "NonGEP CE's are not SRAable!"); - + // 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. @@ -499,7 +499,7 @@ static bool AllUsesOfValueWillTrapIfNull(Value *V) { if (!AllUsesOfValueWillTrapIfNull(CI)) return false; } else if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(*UI)) { if (!AllUsesOfValueWillTrapIfNull(GEPI)) return false; - } else if (isa<SetCondInst>(*UI) && + } else if (isa<SetCondInst>(*UI) && isa<ConstantPointerNull>(UI->getOperand(1))) { // Ignore setcc X, null } else { @@ -681,7 +681,7 @@ static GlobalVariable *OptimizeGlobalAddressOfMalloc(GlobalVariable *GV, MI->eraseFromParent(); MI = NewMI; } - + // Create the new global variable. The contents of the malloc'd memory is // undefined, so initialize with an undef value. Constant *Init = UndefValue::get(MI->getAllocatedType()); @@ -689,7 +689,7 @@ static GlobalVariable *OptimizeGlobalAddressOfMalloc(GlobalVariable *GV, GlobalValue::InternalLinkage, Init, GV->getName()+".body"); GV->getParent()->getGlobalList().insert(GV, NewGV); - + // Anything that used the malloc now uses the global directly. MI->replaceAllUsesWith(NewGV); @@ -699,8 +699,8 @@ static GlobalVariable *OptimizeGlobalAddressOfMalloc(GlobalVariable *GV, // If there is a comparison against null, we will insert a global bool to // keep track of whether the global was initialized yet or not. - GlobalVariable *InitBool = - new GlobalVariable(Type::BoolTy, false, GlobalValue::InternalLinkage, + GlobalVariable *InitBool = + new GlobalVariable(Type::BoolTy, false, GlobalValue::InternalLinkage, ConstantBool::False, GV->getName()+".init"); bool InitBoolUsed = false; @@ -817,7 +817,7 @@ static bool OptimizeOnceStoredGlobal(GlobalVariable *GV, Value *StoredOnceVal, if (Constant *SOVC = dyn_cast<Constant>(StoredOnceVal)) { if (GV->getInitializer()->getType() != SOVC->getType()) SOVC = ConstantExpr::getCast(SOVC, GV->getInitializer()->getType()); - + // Optimize away any trapping uses of the loaded value. if (OptimizeAwayTrappingUsesOfLoads(GV, SOVC)) return true; @@ -846,7 +846,7 @@ static bool OptimizeOnceStoredGlobal(GlobalVariable *GV, Value *StoredOnceVal, } /// ShrinkGlobalToBoolean - At this point, we have learned that the only two -/// values ever stored into GV are its initializer and OtherVal. +/// values ever stored into GV are its initializer and OtherVal. static void ShrinkGlobalToBoolean(GlobalVariable *GV, Constant *OtherVal) { // Create the new global, initializing it to false. GlobalVariable *NewGV = new GlobalVariable(Type::BoolTy, false, @@ -895,13 +895,13 @@ static void ShrinkGlobalToBoolean(GlobalVariable *GV, Constant *OtherVal) { } else if (!UI->use_empty()) { // Change the load into a load of bool then a select. LoadInst *LI = cast<LoadInst>(UI); - + std::string Name = LI->getName(); LI->setName(""); LoadInst *NLI = new LoadInst(NewGV, Name+".b", LI); Value *NSI; if (IsOneZero) NSI = new CastInst(NLI, LI->getType(), Name, LI); - else + else NSI = new SelectInst(NLI, OtherVal, InitVal, Name, LI); LI->replaceAllUsesWith(NSI); } @@ -947,7 +947,7 @@ bool GlobalOpt::ProcessInternalGlobal(GlobalVariable *GV, AllocaInst* Alloca = new AllocaInst(ElemTy, NULL, GV->getName(), FirstI); if (!isa<UndefValue>(GV->getInitializer())) new StoreInst(GV->getInitializer(), Alloca, FirstI); - + GV->replaceAllUsesWith(Alloca); GV->eraseFromParent(); ++NumLocalized; @@ -969,14 +969,14 @@ bool GlobalOpt::ProcessInternalGlobal(GlobalVariable *GV, Changed = true; } return Changed; - + } else if (GS.StoredType <= GlobalStatus::isInitializerStored) { DEBUG(std::cerr << "MARKING CONSTANT: " << *GV); GV->setConstant(true); - + // Clean up any obviously simplifiable users now. CleanupConstantGlobalUsers(GV, GV->getInitializer()); - + // If the global is dead now, just nuke it. if (GV->use_empty()) { DEBUG(std::cerr << " *** Marking constant allowed us to simplify " @@ -984,7 +984,7 @@ bool GlobalOpt::ProcessInternalGlobal(GlobalVariable *GV, GV->eraseFromParent(); ++NumDeleted; } - + ++NumMarked; return true; } else if (!GS.isNotSuitableForSRA && @@ -1002,10 +1002,10 @@ bool GlobalOpt::ProcessInternalGlobal(GlobalVariable *GV, if (isa<UndefValue>(GV->getInitializer())) { // Change the initial value here. GV->setInitializer(SOVConstant); - + // Clean up any obviously simplifiable users now. CleanupConstantGlobalUsers(GV, GV->getInitializer()); - + if (GV->use_empty()) { DEBUG(std::cerr << " *** Substituting initializer allowed us to " "simplify all users and delete global!\n"); diff --git a/lib/Transforms/IPO/IPConstantPropagation.cpp b/lib/Transforms/IPO/IPConstantPropagation.cpp index 16839ed..02395b5 100644 --- a/lib/Transforms/IPO/IPConstantPropagation.cpp +++ b/lib/Transforms/IPO/IPConstantPropagation.cpp @@ -1,10 +1,10 @@ //===-- IPConstantPropagation.cpp - Propagate constants through calls -----===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This pass implements an _extremely_ simple interprocedural constant @@ -81,10 +81,10 @@ bool IPCP::PropagateConstantsIntoArguments(Function &F) { return false; // Used by a non-instruction, do not transform else { CallSite CS = CallSite::get(cast<Instruction>(*I)); - if (CS.getInstruction() == 0 || + if (CS.getInstruction() == 0 || CS.getCalledFunction() != &F) return false; // Not a direct call site? - + // Check out all of the potentially constant arguments CallSite::arg_iterator AI = CS.arg_begin(); Function::arg_iterator Arg = F.arg_begin(); @@ -163,7 +163,7 @@ bool IPCP::PropagateConstantReturn(Function &F) { ReplacedAllUsers = false; else { CallSite CS = CallSite::get(cast<Instruction>(*I)); - if (CS.getInstruction() == 0 || + if (CS.getInstruction() == 0 || CS.getCalledFunction() != &F) { ReplacedAllUsers = false; } else { diff --git a/lib/Transforms/IPO/InlineSimple.cpp b/lib/Transforms/IPO/InlineSimple.cpp index 4355c6c..4bbefa3 100644 --- a/lib/Transforms/IPO/InlineSimple.cpp +++ b/lib/Transforms/IPO/InlineSimple.cpp @@ -1,10 +1,10 @@ //===- InlineSimple.cpp - Code to perform simple function inlining --------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements bottom-up inlining of functions into callees. @@ -101,7 +101,7 @@ static unsigned CountCodeReductionForConstant(Value *V) { if (AllOperandsConstant) { // We will get to remove this instruction... Reduction += 7; - + // And any other instructions that use it which become constants // themselves. Reduction += CountCodeReductionForConstant(&Inst); diff --git a/lib/Transforms/IPO/Inliner.cpp b/lib/Transforms/IPO/Inliner.cpp index 9c8d7aa..36955e1 100644 --- a/lib/Transforms/IPO/Inliner.cpp +++ b/lib/Transforms/IPO/Inliner.cpp @@ -1,10 +1,10 @@ //===- Inliner.cpp - Code common to all inliners --------------------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements the mechanics required to implement inlining without @@ -53,18 +53,18 @@ static bool InlineCallIfPossible(CallSite CS, CallGraph &CG, for (CallGraphNode::iterator I = CalleeNode->begin(), E = CalleeNode->end(); I != E; ++I) CallerNode->addCalledFunction(*I); - + // If we inlined the last possible call site to the function, delete the // function body now. if (Callee->use_empty() && Callee->hasInternalLinkage() && !SCCFunctions.count(Callee)) { DEBUG(std::cerr << " -> Deleting dead function: " << Callee->getName() << "\n"); - + // Remove any call graph edges from the callee to its callees. while (CalleeNode->begin() != CalleeNode->end()) CalleeNode->removeCallEdgeTo(*(CalleeNode->end()-1)); - + // Removing the node for callee from the call graph and delete it. delete CG.removeFunctionFromModule(CalleeNode); ++NumDeleted; @@ -99,7 +99,7 @@ bool Inliner::runOnSCC(const std::vector<CallGraphNode*> &SCC) { } DEBUG(std::cerr << ": " << CallSites.size() << " call sites.\n"); - + // Now that we have all of the call sites, move the ones to functions in the // current SCC to the end of the list. unsigned FirstCallInSCC = CallSites.size(); @@ -107,7 +107,7 @@ bool Inliner::runOnSCC(const std::vector<CallGraphNode*> &SCC) { if (Function *F = CallSites[i].getCalledFunction()) if (SCCFunctions.count(F)) std::swap(CallSites[i--], CallSites[--FirstCallInSCC]); - + // Now that we have all of the call sites, loop over them and inline them if // it looks profitable to do so. bool Changed = false; @@ -137,7 +137,7 @@ bool Inliner::runOnSCC(const std::vector<CallGraphNode*> &SCC) { } else { DEBUG(std::cerr << " Inlining: cost=" << InlineCost << ", Call: " << *CS.getInstruction()); - + Function *Caller = CS.getInstruction()->getParent()->getParent(); // Attempt to inline the function... @@ -178,12 +178,12 @@ bool Inliner::doFinalization(CallGraph &CG) { // Remove any call graph edges from the function to its callees. while (CGN->begin() != CGN->end()) CGN->removeCallEdgeTo(*(CGN->end()-1)); - + // Remove any edges from the external node to the function's call graph // node. These edges might have been made irrelegant due to // optimization of the program. CG.getExternalCallingNode()->removeAnyCallEdgeTo(CGN); - + // Removing the node for callee from the call graph and delete it. FunctionsToRemove.insert(CGN); } diff --git a/lib/Transforms/IPO/Inliner.h b/lib/Transforms/IPO/Inliner.h index f937be2..c4662c1 100644 --- a/lib/Transforms/IPO/Inliner.h +++ b/lib/Transforms/IPO/Inliner.h @@ -1,10 +1,10 @@ //===- InlineCommon.h - Code common to all inliners -------------*- C++ -*-===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file defines a simple policy-based bottom-up inliner. This file diff --git a/lib/Transforms/IPO/Internalize.cpp b/lib/Transforms/IPO/Internalize.cpp index 5a254fa..85a7abd 100644 --- a/lib/Transforms/IPO/Internalize.cpp +++ b/lib/Transforms/IPO/Internalize.cpp @@ -1,10 +1,10 @@ //===-- Internalize.cpp - Mark functions internal -------------------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This pass loops over all of the functions in the input module, looking for a @@ -38,7 +38,7 @@ namespace { APIList("internalize-public-api-list", cl::value_desc("list"), cl::desc("A list of symbol names to preserve"), cl::CommaSeparated); - + class InternalizePass : public ModulePass { std::set<std::string> ExternalNames; public: @@ -80,7 +80,7 @@ namespace { } bool Changed = false; - + // Found a main function, mark all functions not named main as internal. for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) if (!I->isExternal() && // Function must be defined here @@ -109,7 +109,7 @@ namespace { ++NumGlobals; DEBUG(std::cerr << "Internalizing gvar " << I->getName() << "\n"); } - + return Changed; } }; diff --git a/lib/Transforms/IPO/LoopExtractor.cpp b/lib/Transforms/IPO/LoopExtractor.cpp index 4fd2335..39d0fca 100644 --- a/lib/Transforms/IPO/LoopExtractor.cpp +++ b/lib/Transforms/IPO/LoopExtractor.cpp @@ -1,10 +1,10 @@ //===- LoopExtractor.cpp - Extract each loop into a new function ----------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // A pass wrapper around the ExtractLoop() scalar transformation to extract each @@ -27,7 +27,7 @@ using namespace llvm; namespace { Statistic<> NumExtracted("loop-extract", "Number of loops extracted"); - + // FIXME: This is not a function pass, but the PassManager doesn't allow // Module passes to require FunctionPasses, so we can't get loop info if we're // not a function pass. @@ -37,7 +37,7 @@ namespace { LoopExtractor(unsigned numLoops = ~0) : NumLoops(numLoops) {} virtual bool runOnFunction(Function &F); - + virtual void getAnalysisUsage(AnalysisUsage &AU) const { AU.addRequiredID(BreakCriticalEdgesID); AU.addRequiredID(LoopSimplifyID); @@ -46,7 +46,7 @@ namespace { } }; - RegisterOpt<LoopExtractor> + RegisterOpt<LoopExtractor> X("loop-extract", "Extract loops into new functions"); /// SingleLoopExtractor - For bugpoint. @@ -54,9 +54,9 @@ namespace { SingleLoopExtractor() : LoopExtractor(1) {} }; - RegisterOpt<SingleLoopExtractor> + RegisterOpt<SingleLoopExtractor> Y("loop-extract-single", "Extract at most one loop into a new function"); -} // End anonymous namespace +} // End anonymous namespace // createLoopExtractorPass - This pass extracts all natural loops from the // program into a function if it can. @@ -87,11 +87,11 @@ bool LoopExtractor::runOnFunction(Function &F) { // than a minimal wrapper around the loop, extract the loop. Loop *TLL = *LI.begin(); bool ShouldExtractLoop = false; - + // Extract the loop if the entry block doesn't branch to the loop header. TerminatorInst *EntryTI = F.getEntryBlock().getTerminator(); if (!isa<BranchInst>(EntryTI) || - !cast<BranchInst>(EntryTI)->isUnconditional() || + !cast<BranchInst>(EntryTI)->isUnconditional() || EntryTI->getSuccessor(0) != TLL->getHeader()) ShouldExtractLoop = true; else { @@ -105,7 +105,7 @@ bool LoopExtractor::runOnFunction(Function &F) { break; } } - + if (ShouldExtractLoop) { if (NumLoops == 0) return Changed; --NumLoops; @@ -184,6 +184,6 @@ bool BlockExtractorPass::runOnModule(Module &M) { for (unsigned i = 0, e = BlocksToExtract.size(); i != e; ++i) ExtractBasicBlock(BlocksToExtract[i]); - + return !BlocksToExtract.empty(); } diff --git a/lib/Transforms/IPO/LowerSetJmp.cpp b/lib/Transforms/IPO/LowerSetJmp.cpp index 38828d9..266729d 100644 --- a/lib/Transforms/IPO/LowerSetJmp.cpp +++ b/lib/Transforms/IPO/LowerSetJmp.cpp @@ -1,10 +1,10 @@ //===- LowerSetJmp.cpp - Code pertaining to lowering set/long jumps -------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements the lowering of setjmp and longjmp to use the @@ -204,7 +204,7 @@ bool LowerSetJmp::doInitialization(Module& M) // void __llvm_sjljeh_init_setjmpmap(void**) InitSJMap = M.getOrInsertFunction("__llvm_sjljeh_init_setjmpmap", - Type::VoidTy, SBPPTy, 0); + Type::VoidTy, SBPPTy, 0); // void __llvm_sjljeh_destroy_setjmpmap(void**) DestroySJMap = M.getOrInsertFunction("__llvm_sjljeh_destroy_setjmpmap", Type::VoidTy, SBPPTy, 0); @@ -386,7 +386,7 @@ void LowerSetJmp::TransformSetJmpCall(CallInst* Inst) // instructions after the call. for (BasicBlock::iterator I = ++BasicBlock::iterator(Inst), E = ABlock->end(); I != E; ++I) - InstrsAfterCall.insert(I); + InstrsAfterCall.insert(I); for (BasicBlock::iterator II = ABlock->begin(); II != BasicBlock::iterator(Inst); ++II) @@ -460,7 +460,7 @@ void LowerSetJmp::visitCallInst(CallInst& CI) std::vector<Value*> Params(CI.op_begin() + 1, CI.op_end()); InvokeInst* II = new InvokeInst(CI.getCalledValue(), NewBB, PrelimBBMap[Func], - Params, CI.getName(), Term); + Params, CI.getName(), Term); // Replace the old call inst with the invoke inst and remove the call. CI.replaceAllUsesWith(II); diff --git a/lib/Transforms/IPO/PruneEH.cpp b/lib/Transforms/IPO/PruneEH.cpp index 9601d14..381722e 100644 --- a/lib/Transforms/IPO/PruneEH.cpp +++ b/lib/Transforms/IPO/PruneEH.cpp @@ -1,10 +1,10 @@ //===- PruneEH.cpp - Pass which deletes unused exception handlers ---------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements a simple interprocedural pass which walks the @@ -77,7 +77,7 @@ bool PruneEH::runOnSCC(const std::vector<CallGraphNode *> &SCC) { SCCMightThrow = true; break; } - + } else { // Indirect call, it might throw. SCCMightThrow = true; @@ -109,24 +109,24 @@ bool PruneEH::runOnSCC(const std::vector<CallGraphNode *> &SCC) { std::vector<Value*>(II->op_begin()+3, II->op_end()), Name, II); - + // Anything that used the value produced by the invoke instruction // now uses the value produced by the call instruction. II->replaceAllUsesWith(Call); II->getUnwindDest()->removePredecessor(II->getParent()); - + // Insert a branch to the normal destination right before the // invoke. new BranchInst(II->getNormalDest(), II); - + // Finally, delete the invoke instruction! I->getInstList().pop_back(); - + ++NumRemoved; MadeChange = true; } } - return MadeChange; + return MadeChange; } diff --git a/lib/Transforms/IPO/RaiseAllocations.cpp b/lib/Transforms/IPO/RaiseAllocations.cpp index 8a35bc3..2b487d0 100644 --- a/lib/Transforms/IPO/RaiseAllocations.cpp +++ b/lib/Transforms/IPO/RaiseAllocations.cpp @@ -1,10 +1,10 @@ //===- RaiseAllocations.cpp - Convert %malloc & %free calls to insts ------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file defines the RaiseAllocations pass which convert malloc and free @@ -33,17 +33,17 @@ namespace { Function *FreeFunc; // Initialized by doPassInitializationVirt public: RaiseAllocations() : MallocFunc(0), FreeFunc(0) {} - + // doPassInitialization - For the raise allocations pass, this finds a // declaration for malloc and free if they exist. // void doInitialization(Module &M); - + // run - This method does the actual work of converting instructions over. // bool runOnModule(Module &M); }; - + RegisterOpt<RaiseAllocations> X("raiseallocs", "Raise allocations from calls to instructions"); } // end anonymous namespace @@ -134,14 +134,14 @@ bool RaiseAllocations::runOnModule(Module &M) { (CS.getCalledFunction() == MallocFunc || std::find(EqPointers.begin(), EqPointers.end(), CS.getCalledValue()) != EqPointers.end())) { - + Value *Source = *CS.arg_begin(); - + // If no prototype was provided for malloc, we may need to cast the // source size. if (Source->getType() != Type::UIntTy) Source = new CastInst(Source, Type::UIntTy, "MallocAmtCast", I); - + std::string Name(I->getName()); I->setName(""); MallocInst *MI = new MallocInst(Type::SByteTy, Source, Name, I); I->replaceAllUsesWith(MI); @@ -183,7 +183,7 @@ bool RaiseAllocations::runOnModule(Module &M) { (CS.getCalledFunction() == FreeFunc || std::find(EqPointers.begin(), EqPointers.end(), CS.getCalledValue()) != EqPointers.end())) { - + // If no prototype was provided for free, we may need to cast the // source pointer. This should be really uncommon, but it's necessary // just in case we are dealing with weird code like this: diff --git a/lib/Transforms/IPO/StripSymbols.cpp b/lib/Transforms/IPO/StripSymbols.cpp index 80fe394..e1f7ea9 100644 --- a/lib/Transforms/IPO/StripSymbols.cpp +++ b/lib/Transforms/IPO/StripSymbols.cpp @@ -1,10 +1,10 @@ //===- StripSymbols.cpp - Strip symbols and debug info from a module ------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements stripping symbols out of symbol tables. @@ -17,7 +17,7 @@ // // Notice that: // * This pass makes code much less readable, so it should only be used in -// situations where the 'strip' utility would be used (such as reducing +// situations where the 'strip' utility would be used (such as reducing // code size, and making it harder to reverse engineer code). // //===----------------------------------------------------------------------===// @@ -63,7 +63,7 @@ static void RemoveDeadConstant(Constant *C) { } else if (!isa<Function>(C)) C->destroyConstant(); - + // If the constant referenced anything, see if we can delete it as well. while (!Operands.empty()) { RemoveDeadConstant(Operands.back()); @@ -144,5 +144,5 @@ bool StripSymbols::runOnModule(Module &M) { RemoveDeadConstant(GV); } - return true; + return true; } diff --git a/lib/Transforms/Instrumentation/BlockProfiling.cpp b/lib/Transforms/Instrumentation/BlockProfiling.cpp index 476a9e8..f92f0ef 100644 --- a/lib/Transforms/Instrumentation/BlockProfiling.cpp +++ b/lib/Transforms/Instrumentation/BlockProfiling.cpp @@ -1,10 +1,10 @@ //===- BlockProfiling.cpp - Insert counters for block profiling -----------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This pass instruments the specified program with counters for basic block or @@ -51,7 +51,7 @@ bool FunctionProfiler::runOnModule(Module &M) { } unsigned NumFunctions = 0; - for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) + for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) if (!I->isExternal()) ++NumFunctions; @@ -62,7 +62,7 @@ bool FunctionProfiler::runOnModule(Module &M) { // Instrument all of the functions... unsigned i = 0; - for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) + for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) if (!I->isExternal()) // Insert counter at the start of the function IncrementCounterInBlock(I->begin(), i++, Counters); @@ -93,7 +93,7 @@ bool BlockProfiler::runOnModule(Module &M) { } unsigned NumBlocks = 0; - for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) + for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) NumBlocks += I->size(); const Type *ATy = ArrayType::get(Type::UIntTy, NumBlocks); @@ -103,7 +103,7 @@ bool BlockProfiler::runOnModule(Module &M) { // Instrument all of the blocks... unsigned i = 0; - for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) + for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) for (Function::iterator BB = I->begin(), E = I->end(); BB != E; ++BB) // Insert counter at the start of the block IncrementCounterInBlock(BB, i++, Counters); diff --git a/lib/Transforms/Instrumentation/EdgeProfiling.cpp b/lib/Transforms/Instrumentation/EdgeProfiling.cpp index c453554..2ac6cc8 100644 --- a/lib/Transforms/Instrumentation/EdgeProfiling.cpp +++ b/lib/Transforms/Instrumentation/EdgeProfiling.cpp @@ -1,10 +1,10 @@ //===- EdgeProfiling.cpp - Insert counters for edge profiling -------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This pass instruments the specified program with counters for edge profiling. diff --git a/lib/Transforms/Instrumentation/EmitFunctions.cpp b/lib/Transforms/Instrumentation/EmitFunctions.cpp index 16d3687..369a784 100644 --- a/lib/Transforms/Instrumentation/EmitFunctions.cpp +++ b/lib/Transforms/Instrumentation/EmitFunctions.cpp @@ -1,10 +1,10 @@ //===-- EmitFunctions.cpp - interface to insert instrumentation -----------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This inserts into the input module three new global constants containing @@ -27,7 +27,7 @@ #include "llvm/Transforms/Instrumentation.h" using namespace llvm; -namespace llvm { +namespace llvm { namespace { enum Color{ @@ -35,11 +35,11 @@ namespace { GREY, BLACK }; - + struct EmitFunctionTable : public ModulePass { bool runOnModule(Module &M); }; - + RegisterOpt<EmitFunctionTable> X("emitfuncs", "Emit a function table for the reoptimizer"); } @@ -48,9 +48,9 @@ static char doDFS(BasicBlock * node,std::map<BasicBlock *, Color > &color){ color[node] = GREY; for(succ_iterator vl = succ_begin(node), ve = succ_end(node); vl != ve; ++vl){ - - BasicBlock *BB = *vl; - + + BasicBlock *BB = *vl; + if(color[BB]!=GREY && color[BB]!=BLACK){ if(!doDFS(BB, color)){ return 0; @@ -75,7 +75,7 @@ static char hasBackEdge(Function *F){ // Per Module pass for inserting function table bool EmitFunctionTable::runOnModule(Module &M){ std::vector<const Type*> vType; - + std::vector<Constant *> vConsts; std::vector<Constant *> sBCons; @@ -83,24 +83,24 @@ bool EmitFunctionTable::runOnModule(Module &M){ for(Module::iterator MI = M.begin(), ME = M.end(); MI != ME; ++MI) if (!MI->isExternal()) { vType.push_back(MI->getType()); - + //std::cerr<<MI; vConsts.push_back(MI); sBCons.push_back(ConstantInt::get(Type::SByteTy, hasBackEdge(MI))); - + counter++; } - + StructType *sttype = StructType::get(vType); Constant *cstruct = ConstantStruct::get(sttype, vConsts); GlobalVariable *gb = new GlobalVariable(cstruct->getType(), true, - GlobalValue::ExternalLinkage, + GlobalValue::ExternalLinkage, cstruct, "llvmFunctionTable"); M.getGlobalList().push_back(gb); - Constant *constArray = ConstantArray::get(ArrayType::get(Type::SByteTy, + Constant *constArray = ConstantArray::get(ArrayType::get(Type::SByteTy, sBCons.size()), sBCons); @@ -110,9 +110,9 @@ bool EmitFunctionTable::runOnModule(Module &M){ M.getGlobalList().push_back(funcArray); - ConstantInt *cnst = ConstantSInt::get(Type::IntTy, counter); - GlobalVariable *fnCount = new GlobalVariable(Type::IntTy, true, - GlobalValue::ExternalLinkage, + ConstantInt *cnst = ConstantSInt::get(Type::IntTy, counter); + GlobalVariable *fnCount = new GlobalVariable(Type::IntTy, true, + GlobalValue::ExternalLinkage, cnst, "llvmFunctionCount"); M.getGlobalList().push_back(fnCount); return true; // Always modifies program diff --git a/lib/Transforms/Instrumentation/ProfilePaths/CombineBranch.cpp b/lib/Transforms/Instrumentation/ProfilePaths/CombineBranch.cpp index 1a7b773..e592d28 100644 --- a/lib/Transforms/Instrumentation/ProfilePaths/CombineBranch.cpp +++ b/lib/Transforms/Instrumentation/ProfilePaths/CombineBranch.cpp @@ -1,10 +1,10 @@ //===-- CombineBranch.cpp -------------------------------------------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // Combine multiple back-edges going to the same sink into a single @@ -31,14 +31,14 @@ namespace { void getBackEdgesVisit(BasicBlock *u, std::map<BasicBlock *, Color > &color, - std::map<BasicBlock *, int > &d, + std::map<BasicBlock *, int > &d, int &time, std::map<BasicBlock *, BasicBlock *> &be); void removeRedundant(std::map<BasicBlock *, BasicBlock *> &be); public: bool runOnFunction(Function &F); }; - + RegisterOpt<CombineBranches> X("branch-combine", "Multiple backedges going to same target are merged"); } @@ -53,10 +53,10 @@ namespace { /// void CombineBranches::getBackEdgesVisit(BasicBlock *u, std::map<BasicBlock *, Color > &color, - std::map<BasicBlock *, int > &d, + std::map<BasicBlock *, int > &d, int &time, std::map<BasicBlock *, BasicBlock *> &be) { - + color[u]=GREY; time++; d[u]=time; @@ -66,7 +66,7 @@ void CombineBranches::getBackEdgesVisit(BasicBlock *u, if(color[BB]!=GREY && color[BB]!=BLACK) getBackEdgesVisit(BB, color, d, time, be); - + //now checking for d and f vals else if(color[BB]==GREY){ //so v is ancestor of u if time of u > time of v @@ -83,29 +83,29 @@ void CombineBranches::getBackEdgesVisit(BasicBlock *u, void CombineBranches::removeRedundant(std::map<BasicBlock *, BasicBlock *> &be){ std::vector<BasicBlock *> toDelete; std::map<BasicBlock *, int> seenBB; - - for(std::map<BasicBlock *, BasicBlock *>::iterator MI = be.begin(), + + for(std::map<BasicBlock *, BasicBlock *>::iterator MI = be.begin(), ME = be.end(); MI != ME; ++MI){ - + if(seenBB[MI->second]) continue; - + seenBB[MI->second] = 1; std::vector<BasicBlock *> sameTarget; sameTarget.clear(); - - for(std::map<BasicBlock *, BasicBlock *>::iterator MMI = be.begin(), + + for(std::map<BasicBlock *, BasicBlock *>::iterator MMI = be.begin(), MME = be.end(); MMI != MME; ++MMI){ - + if(MMI->first == MI->first) continue; - + if(MMI->second == MI->second) sameTarget.push_back(MMI->first); - + } - + //so more than one branch to same target if(sameTarget.size()){ @@ -126,9 +126,9 @@ void CombineBranches::removeRedundant(std::map<BasicBlock *, BasicBlock *> &be){ ti->setSuccessor(index, newBB); - for(BasicBlock::iterator BB2Inst = MI->second->begin(), + for(BasicBlock::iterator BB2Inst = MI->second->begin(), BBend = MI->second->end(); BB2Inst != BBend; ++BB2Inst){ - + if (PHINode *phiInst = dyn_cast<PHINode>(BB2Inst)){ int bbIndex; bbIndex = phiInst->getBasicBlockIndex(*VBI); @@ -178,7 +178,7 @@ bool CombineBranches::runOnFunction(Function &F){ int time = 0; getBackEdgesVisit (F.begin (), color, d, time, be); removeRedundant (be); - + return true; // FIXME: assumes a modification was always made. } diff --git a/lib/Transforms/Instrumentation/ProfilePaths/EdgeCode.cpp b/lib/Transforms/Instrumentation/ProfilePaths/EdgeCode.cpp index 8e7bd78..aef4681 100644 --- a/lib/Transforms/Instrumentation/ProfilePaths/EdgeCode.cpp +++ b/lib/Transforms/Instrumentation/ProfilePaths/EdgeCode.cpp @@ -1,16 +1,16 @@ //===-- EdgeCode.cpp - generate LLVM instrumentation code -----------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// -//It implements the class EdgeCode: which provides +//It implements the class EdgeCode: which provides //support for inserting "appropriate" instrumentation at //designated points in the graph // -//It also has methods to insert initialization code in +//It also has methods to insert initialization code in //top block of cfg //===----------------------------------------------------------------------===// @@ -29,8 +29,8 @@ using std::vector; namespace llvm { static void getTriggerCode(Module *M, BasicBlock *BB, int MethNo, Value *pathNo, - Value *cnt, Instruction *rInst){ - + Value *cnt, Instruction *rInst){ + vector<Value *> tmpVec; tmpVec.push_back(Constant::getNullValue(Type::LongTy)); tmpVec.push_back(Constant::getNullValue(Type::LongTy)); @@ -38,7 +38,7 @@ static void getTriggerCode(Module *M, BasicBlock *BB, int MethNo, Value *pathNo, BB->getInstList().push_back(Idx); const Type *PIntTy = PointerType::get(Type::IntTy); - Function *trigMeth = M->getOrInsertFunction("trigger", Type::VoidTy, + Function *trigMeth = M->getOrInsertFunction("trigger", Type::VoidTy, Type::IntTy, Type::IntTy, PIntTy, PIntTy, 0); assert(trigMeth && "trigger method could not be inserted!"); @@ -58,18 +58,18 @@ static void getTriggerCode(Module *M, BasicBlock *BB, int MethNo, Value *pathNo, //get the code to be inserted on the edge //This is determined from cond (1-6) -void getEdgeCode::getCode(Instruction *rInst, Value *countInst, - Function *M, BasicBlock *BB, +void getEdgeCode::getCode(Instruction *rInst, Value *countInst, + Function *M, BasicBlock *BB, vector<Value *> &retVec){ - + //Instruction *InsertPos = BB->getInstList().begin(); - + //now check for cdIn and cdOut //first put cdOut if(cdOut!=NULL){ cdOut->getCode(rInst, countInst, M, BB, retVec); } - + if(cdIn!=NULL){ cdIn->getCode(rInst, countInst, M, BB, retVec); } @@ -93,7 +93,7 @@ void getEdgeCode::getCode(Instruction *rInst, Value *countInst, #endif break; } - + //r+=k case 3:{ Instruction *ldInst = new LoadInst(rInst, "ti1");//, InsertPos); @@ -116,33 +116,33 @@ void getEdgeCode::getCode(Instruction *rInst, Value *countInst, tmpVec.push_back(ConstantSInt::get(Type::LongTy, inc)); Instruction *Idx = new GetElementPtrInst(countInst, tmpVec, "");//, - //Instruction *Idx = new GetElementPtrInst(countInst, + //Instruction *Idx = new GetElementPtrInst(countInst, // vector<Value*>(1,ConstantSInt::get(Type::LongTy, inc)), // "");//, InsertPos); BB->getInstList().push_back(Idx); Instruction *ldInst=new LoadInst(Idx, "ti1");//, InsertPos); BB->getInstList().push_back(ldInst); - + Value *val = ConstantSInt::get(Type::IntTy, 1); //Instruction *addIn = Instruction *newCount = BinaryOperator::create(Instruction::Add, ldInst, val,"ti2"); BB->getInstList().push_back(newCount); - + #ifdef INSERT_STORE //Instruction *stInst=new StoreInst(addIn, Idx, InsertPos); Instruction *stInst=new StoreInst(newCount, Idx);//, InsertPos); BB->getInstList().push_back(stInst); #endif - + Value *trAddIndex = ConstantSInt::get(Type::IntTy,inc); retVec.push_back(newCount); retVec.push_back(trAddIndex); //insert trigger - //getTriggerCode(M->getParent(), BB, MethNo, + //getTriggerCode(M->getParent(), BB, MethNo, // ConstantSInt::get(Type::IntTy,inc), newCount, triggerInst); //end trigger code @@ -152,7 +152,7 @@ void getEdgeCode::getCode(Instruction *rInst, Value *countInst, //case: count[r+inc]++ case 5:{ - + //ti1=inc+r Instruction *ldIndex=new LoadInst(rInst, "ti1");//, InsertPos); BB->getInstList().push_back(ldIndex); @@ -161,9 +161,9 @@ void getEdgeCode::getCode(Instruction *rInst, Value *countInst, Instruction *addIndex=BinaryOperator:: create(Instruction::Add, ldIndex, val,"ti2");//, InsertPos); BB->getInstList().push_back(addIndex); - + //now load count[addIndex] - Instruction *castInst=new CastInst(addIndex, + Instruction *castInst=new CastInst(addIndex, Type::LongTy,"ctin");//, InsertPos); BB->getInstList().push_back(castInst); @@ -180,10 +180,10 @@ void getEdgeCode::getCode(Instruction *rInst, Value *countInst, Value *cons=ConstantSInt::get(Type::IntTy,1); //count[addIndex]++ //std::cerr<<"Type ldInst:"<<ldInst->getType()<<"\t cons:"<<cons->getType()<<"\n"; - Instruction *newCount = BinaryOperator::create(Instruction::Add, ldInst, + Instruction *newCount = BinaryOperator::create(Instruction::Add, ldInst, cons,""); BB->getInstList().push_back(newCount); - + #ifdef INSERT_STORE Instruction *stInst = new StoreInst(newCount, Idx);//, InsertPos); BB->getInstList().push_back(stInst); @@ -213,11 +213,11 @@ void getEdgeCode::getCode(Instruction *rInst, Value *countInst, tmpVec.push_back(castInst2); Instruction *Idx = new GetElementPtrInst(countInst, tmpVec, "");//, - //Instruction *Idx = new GetElementPtrInst(countInst, + //Instruction *Idx = new GetElementPtrInst(countInst, // vector<Value*>(1,castInst2), ""); - + BB->getInstList().push_back(Idx); - + Instruction *ldInst=new LoadInst(Idx, "ti2");//, InsertPos); BB->getInstList().push_back(ldInst); @@ -237,7 +237,7 @@ void getEdgeCode::getCode(Instruction *rInst, Value *countInst, retVec.push_back(ldIndex); break; } - + } } @@ -245,25 +245,25 @@ void getEdgeCode::getCode(Instruction *rInst, Value *countInst, //Insert the initialization code in the top BB //this includes initializing r, and count -//r is like an accumulator, that +//r is like an accumulator, that //keeps on adding increments as we traverse along a path //and at the end of the path, r contains the path //number of that path //Count is an array, where Count[k] represents //the number of executions of path k -void insertInTopBB(BasicBlock *front, - int k, +void insertInTopBB(BasicBlock *front, + int k, Instruction *rVar, Value *threshold){ - //rVar is variable r, + //rVar is variable r, //countVar is count[] Value *Int0 = ConstantInt::get(Type::IntTy, 0); - + //now push all instructions in front of the BB BasicBlock::iterator here=front->begin(); front->getInstList().insert(here, rVar); //front->getInstList().insert(here,countVar); - + //Initialize Count[...] with 0 //for (int i=0;i<k; i++){ @@ -281,22 +281,22 @@ void insertInTopBB(BasicBlock *front, //insert a basic block with appropriate code //along a given edge void insertBB(Edge ed, - getEdgeCode *edgeCode, - Instruction *rInst, - Value *countInst, + getEdgeCode *edgeCode, + Instruction *rInst, + Value *countInst, int numPaths, int Methno, Value *threshold){ BasicBlock* BB1=ed.getFirst()->getElement(); BasicBlock* BB2=ed.getSecond()->getElement(); - + #ifdef DEBUG_PATH_PROFILES //debugging info cerr<<"Edges with codes ######################\n"; cerr<<BB1->getName()<<"->"<<BB2->getName()<<"\n"; cerr<<"########################\n"; #endif - - //We need to insert a BB between BB1 and BB2 + + //We need to insert a BB between BB1 and BB2 TerminatorInst *TI=BB1->getTerminator(); BasicBlock *newBB=new BasicBlock("counter", BB1->getParent()); @@ -316,7 +316,7 @@ void insertBB(Edge ed, else{ if(BI->getSuccessor(0)==BB2) BI->setSuccessor(0, newBB); - + if(BI->getSuccessor(1)==BB2) BI->setSuccessor(1, newBB); } @@ -324,21 +324,21 @@ void insertBB(Edge ed, BasicBlock *triggerBB = NULL; if(retVec.size()>0){ triggerBB = new BasicBlock("trigger", BB1->getParent()); - getTriggerCode(BB1->getParent()->getParent(), triggerBB, Methno, + getTriggerCode(BB1->getParent()->getParent(), triggerBB, Methno, retVec[1], countInst, rInst);//retVec[0]); //Instruction *castInst = new CastInst(retVec[0], Type::IntTy, ""); Instruction *etr = new LoadInst(threshold, "threshold"); - - //std::cerr<<"type1: "<<etr->getType()<<" type2: "<<retVec[0]->getType()<<"\n"; - Instruction *cmpInst = new SetCondInst(Instruction::SetLE, etr, + + //std::cerr<<"type1: "<<etr->getType()<<" type2: "<<retVec[0]->getType()<<"\n"; + Instruction *cmpInst = new SetCondInst(Instruction::SetLE, etr, retVec[0], ""); Instruction *newBI2 = new BranchInst(triggerBB, BB2, cmpInst); //newBB->getInstList().push_back(castInst); newBB->getInstList().push_back(etr); newBB->getInstList().push_back(cmpInst); newBB->getInstList().push_back(newBI2); - + //triggerBB->getInstList().push_back(triggerInst); new BranchInst(BB2, 0, 0, triggerBB); } @@ -347,9 +347,9 @@ void insertBB(Edge ed, } //now iterate over BB2, and set its Phi nodes right - for(BasicBlock::iterator BB2Inst = BB2->begin(), BBend = BB2->end(); + for(BasicBlock::iterator BB2Inst = BB2->begin(), BBend = BB2->end(); BB2Inst != BBend; ++BB2Inst){ - + if(PHINode *phiInst=dyn_cast<PHINode>(BB2Inst)){ int bbIndex=phiInst->getBasicBlockIndex(BB1); assert(bbIndex>=0); diff --git a/lib/Transforms/Instrumentation/ProfilePaths/Graph.cpp b/lib/Transforms/Instrumentation/ProfilePaths/Graph.cpp index 21a6e93..21883c4 100644 --- a/lib/Transforms/Instrumentation/ProfilePaths/Graph.cpp +++ b/lib/Transforms/Instrumentation/ProfilePaths/Graph.cpp @@ -1,10 +1,10 @@ //===-- Graph.cpp - Implements Graph class --------------------------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This implements Graph for helping in trace generation This graph gets used by @@ -23,7 +23,7 @@ namespace llvm { const graphListElement *findNodeInList(const Graph::nodeList &NL, Node *N) { - for(Graph::nodeList::const_iterator NI = NL.begin(), NE=NL.end(); NI != NE; + for(Graph::nodeList::const_iterator NI = NL.begin(), NE=NL.end(); NI != NE; ++NI) if (*NI->element== *N) return &*NI; @@ -38,7 +38,7 @@ graphListElement *findNodeInList(Graph::nodeList &NL, Node *N) { } //graph constructor with root and exit specified -Graph::Graph(std::vector<Node*> n, std::vector<Edge> e, +Graph::Graph(std::vector<Node*> n, std::vector<Edge> e, Node *rt, Node *lt){ strt=rt; ext=lt; @@ -49,17 +49,17 @@ Graph::Graph(std::vector<Node*> n, std::vector<Edge> e, for(vector<Edge >::iterator x=e.begin(), en=e.end(); x!=en; ++x){ Edge ee=*x; int w=ee.getWeight(); - //nodes[ee.getFirst()].push_front(graphListElement(ee.getSecond(),w, ee.getRandId())); + //nodes[ee.getFirst()].push_front(graphListElement(ee.getSecond(),w, ee.getRandId())); nodes[ee.getFirst()].push_back(graphListElement(ee.getSecond(),w, ee.getRandId())); } - + } //sorting edgelist, called by backEdgeVist ONLY!!! Graph::nodeList &Graph::sortNodeList(Node *par, nodeList &nl, vector<Edge> &be){ assert(par && "null node pointer"); BasicBlock *bbPar = par->getElement(); - + if(nl.size()<=1) return nl; if(getExit() == par) return nl; @@ -79,7 +79,7 @@ Graph::nodeList &Graph::sortNodeList(Node *par, nodeList &nl, vector<Edge> &be){ assert(ti && "not a branch"); assert(ti->getNumSuccessors()==2 && "less successors!"); - + BasicBlock *tB = ti->getSuccessor(0); BasicBlock *fB = ti->getSuccessor(1); //so one of LI or min must be back edge! @@ -109,24 +109,24 @@ Graph::nodeList &Graph::sortNodeList(Node *par, nodeList &nl, vector<Edge> &be){ } } } - + else if (min->element->getElement() != LI->element->getElement()){ TerminatorInst *tti = par->getElement()->getTerminator(); BranchInst *ti = cast<BranchInst>(tti); assert(ti && "not a branch"); if(ti->getNumSuccessors()<=1) continue; - + assert(ti->getNumSuccessors()==2 && "less successors!"); - + BasicBlock *tB = ti->getSuccessor(0); BasicBlock *fB = ti->getSuccessor(1); - + if(tB == LI->element->getElement() || fB == min->element->getElement()) min = LI; } } - + graphListElement tmpElmnt = *min; *min = *NLI; *NLI = tmpElmnt; @@ -159,11 +159,11 @@ bool Graph::hasEdgeAndWt(Edge ed){ Node *nd2=ed.getSecond(); nodeList &nli = nodes[ed.getFirst()];//getNodeList(ed.getFirst()); - + for(nodeList::iterator NI=nli.begin(), NE=nli.end(); NI!=NE; ++NI) if(*NI->element == *nd2 && ed.getWeight()==NI->weight) return true; - + return false; } @@ -180,9 +180,9 @@ void Graph::addNode(Node *nd){ } //add an edge -//this adds an edge ONLY when +//this adds an edge ONLY when //the edge to be added does not already exist -//we "equate" two edges here only with their +//we "equate" two edges here only with their //end points void Graph::addEdge(Edge ed, int w){ nodeList &ndList = nodes[ed.getFirst()]; @@ -190,7 +190,7 @@ void Graph::addEdge(Edge ed, int w){ if(findNodeInList(nodes[ed.getFirst()], nd2)) return; - + //ndList.push_front(graphListElement(nd2,w, ed.getRandId())); ndList.push_back(graphListElement(nd2,w, ed.getRandId()));//chng //sortNodeList(ed.getFirst(), ndList); @@ -296,7 +296,7 @@ int Graph::getNumberOfIncomingEdges(Node *nd){ for(nodeMapTy::const_iterator EI=nodes.begin(), EE=nodes.end(); EI!=EE ;++EI){ Node *lnode=EI->first; const nodeList &nl = getNodeList(lnode); - for(Graph::nodeList::const_iterator NI = nl.begin(), NE=nl.end(); NI != NE; + for(Graph::nodeList::const_iterator NI = nl.begin(), NE=nl.end(); NI != NE; ++NI) if (*NI->element== *nd) count++; @@ -340,19 +340,19 @@ static void printNode(Node *nd){ //of the graph Graph* Graph::getMaxSpanningTree(){ //assume connected graph - + Graph *st=new Graph();//max spanning tree, undirected edges int inf=9999999;//largest key vector<Node *> lt = getAllNodes(); - + //initially put all vertices in vector vt //assign wt(root)=0 //wt(others)=infinity // //now: //pull out u: a vertex frm vt of min wt - //for all vertices w in vt, - //if wt(w) greater than + //for all vertices w in vt, + //if wt(w) greater than //the wt(u->w), then assign //wt(w) to be wt(u->w). // @@ -360,7 +360,7 @@ Graph* Graph::getMaxSpanningTree(){ //keep pulling out vertices from vt till it is empty vector<Node *> vt; - + std::map<Node*, Node* > parent; std::map<Node*, int > ed_weight; @@ -373,7 +373,7 @@ Graph* Graph::getMaxSpanningTree(){ parent[thisNode]=NULL; ed_weight[thisNode]=0; } - else{ + else{ thisNode->setWeight(inf); } st->addNode(thisNode);//add all nodes to spanning tree @@ -396,7 +396,7 @@ Graph* Graph::getMaxSpanningTree(){ } //vt.erase(u); - + //remove u frm vt for(vector<Node *>::iterator VI=vt.begin(), VE=vt.end(); VI!=VE; ++VI){ if(**VI==*u){ @@ -404,7 +404,7 @@ Graph* Graph::getMaxSpanningTree(){ break; } } - + //assign wt(v) to all adjacent vertices v of u //only if v is in vt Graph::nodeList &nl = getNodeList(u); @@ -438,7 +438,7 @@ Graph* Graph::getMaxSpanningTree(){ return st; } -//print the graph (for debugging) +//print the graph (for debugging) void Graph::printGraph(){ vector<Node *> lt=getAllNodes(); std::cerr<<"Graph---------------------\n"; @@ -469,7 +469,7 @@ vector<Node *> Graph::reverseTopologicalSort(){ } //a private method for doing DFS traversal of graph -//this is used in determining the reverse topological sort +//this is used in determining the reverse topological sort //of the graph void Graph::DFS_Visit(Node *nd, vector<Node *> &toReturn){ nd->setWeight(GREY); @@ -482,13 +482,13 @@ void Graph::DFS_Visit(Node *nd, vector<Node *> &toReturn){ } //Ordinarily, the graph is directional -//this converts the graph into an +//this converts the graph into an //undirectional graph //This is done by adding an edge //v->u for all existing edges u->v void Graph::makeUnDirectional(){ vector<Node* > allNodes=getAllNodes(); - for(vector<Node *>::iterator NI=allNodes.begin(), NE=allNodes.end(); NI!=NE; + for(vector<Node *>::iterator NI=allNodes.begin(), NE=allNodes.end(); NI!=NE; ++NI) { nodeList &nl = getNodeList(*NI); for(nodeList::iterator NLI=nl.begin(), NLE=nl.end(); NLI!=NLE; ++NLI){ @@ -507,10 +507,10 @@ void Graph::makeUnDirectional(){ //using min-spanning tree, and vice versa void Graph::reverseWts(){ vector<Node *> allNodes=getAllNodes(); - for(vector<Node *>::iterator NI=allNodes.begin(), NE=allNodes.end(); NI!=NE; + for(vector<Node *>::iterator NI=allNodes.begin(), NE=allNodes.end(); NI!=NE; ++NI) { nodeList &node_list = getNodeList(*NI); - for(nodeList::iterator NLI=nodes[*NI].begin(), NLE=nodes[*NI].end(); + for(nodeList::iterator NLI=nodes[*NI].begin(), NLE=nodes[*NI].end(); NLI!=NLE; ++NLI) NLI->weight=-NLI->weight; } @@ -535,7 +535,7 @@ void Graph::getBackEdges(vector<Edge > &be, std::map<Node *, int> &d){ getBackEdgesVisit(getRoot(), be, color, d, time); } -//helper function to get back edges: it is called by +//helper function to get back edges: it is called by //the "getBackEdges" function above void Graph::getBackEdgesVisit(Node *u, vector<Edge > &be, std::map<Node *, Color > &color, @@ -545,14 +545,14 @@ void Graph::getBackEdgesVisit(Node *u, vector<Edge > &be, d[u]=time; vector<graphListElement> &succ_list = getNodeList(u); - - for(vector<graphListElement>::iterator vl=succ_list.begin(), + + for(vector<graphListElement>::iterator vl=succ_list.begin(), ve=succ_list.end(); vl!=ve; ++vl){ Node *v=vl->element; if(color[v]!=GREY && color[v]!=BLACK){ getBackEdgesVisit(v, be, color, d, time); } - + //now checking for d and f vals if(color[v]==GREY){ //so v is ancestor of u if time of u > time of v diff --git a/lib/Transforms/Instrumentation/ProfilePaths/Graph.h b/lib/Transforms/Instrumentation/ProfilePaths/Graph.h index 44b63a9..2039484 100644 --- a/lib/Transforms/Instrumentation/ProfilePaths/Graph.h +++ b/lib/Transforms/Instrumentation/ProfilePaths/Graph.h @@ -1,10 +1,10 @@ //===-- Graph.h -------------------------------------------------*- C++ -*-===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // Header file for Graph: This Graph is used by PathProfiles class, and is used @@ -58,13 +58,13 @@ public: randId=rand(); isnull=false; } - + inline Edge(Node *f,Node *s, int wt, double rd){ first=f; second=s; weight=wt; randId=rd; - isnull=false; + isnull=false; } inline Edge() { isnull = true; } @@ -73,22 +73,22 @@ public: inline Node* const getFirst() const { assert(!isNull()); return first; } inline Node* getSecond() { assert(!isNull()); return second; } inline Node* const getSecond() const { assert(!isNull()); return second; } - + inline int getWeight() { assert(!isNull()); return weight; } inline void setWeight(int n) { assert(!isNull()); weight=n; } - + inline void setFirst(Node *&f) { assert(!isNull()); first=f; } inline void setSecond(Node *&s) { assert(!isNull()); second=s; } - - - inline bool isNull() const { return isnull;} - + + + inline bool isNull() const { return isnull;} + inline bool operator<(const Edge& ed) const{ // Can't be the same if one is null and the other isn't if (isNull() != ed.isNull()) return true; - return (*first<*(ed.getFirst()))|| + return (*first<*(ed.getFirst()))|| (*first==*(ed.getFirst()) && *second<*(ed.getSecond())); } @@ -96,19 +96,19 @@ public: return !(*this<ed) && !(ed<*this); } - inline bool operator!=(const Edge& ed) const{return !(*this==ed);} + inline bool operator!=(const Edge& ed) const{return !(*this==ed);} }; //graphListElement -//This forms the "adjacency list element" of a +//This forms the "adjacency list element" of a //vertex adjacency list in graph struct graphListElement{ Node *element; int weight; double randId; - inline graphListElement(Node *n, int w, double rand){ - element=n; + inline graphListElement(Node *n, int w, double rand){ + element=n; weight=w; randId=rand; } @@ -127,12 +127,12 @@ using namespace llvm; return n1->getElement() < n2->getElement(); } }; - + template<> struct less<Edge> : public binary_function<Edge,Edge,bool> { bool operator()(Edge e1, Edge e2) const { assert(!e1.isNull() && !e2.isNull()); - + Node *x1=e1.getFirst(); Node *x2=e1.getSecond(); Node *y1=e2.getFirst(); @@ -210,7 +210,7 @@ public: private: //the adjacency list of a vertex or node nodeMapTy nodes; - + //the start or root node Node *strt; @@ -218,7 +218,7 @@ private: Node *ext; //a private method for doing DFS traversal of graph - //this is used in determining the reverse topological sort + //this is used in determining the reverse topological sort //of the graph void DFS_Visit(Node *nd, std::vector<Node *> &toReturn); @@ -232,10 +232,10 @@ private: //have been visited //So we have a back edge when we meet a successor of //a node with smaller time, and GREY color - void getBackEdgesVisit(Node *u, + void getBackEdgesVisit(Node *u, std::vector<Edge > &be, std::map<Node *, Color> &clr, - std::map<Node *, int> &d, + std::map<Node *, int> &d, int &time); public: @@ -248,18 +248,18 @@ public: //empty constructor: then add edges and nodes later on Graph() {} - + //constructor with root and exit node specified - Graph(std::vector<Node*> n, + Graph(std::vector<Node*> n, std::vector<Edge> e, Node *rt, Node *lt); //add a node void addNode(Node *nd); //add an edge - //this adds an edge ONLY when + //this adds an edge ONLY when //the edge to be added doesn not already exist - //we "equate" two edges here only with their + //we "equate" two edges here only with their //end points void addEdge(Edge ed, int w); @@ -310,14 +310,14 @@ public: //in r-topological sorted order //note that we assumed graph to be connected std::vector<Node *> reverseTopologicalSort(); - + //reverse the sign of weights on edges //this way, max-spanning tree could be obtained //usin min-spanning tree, and vice versa void reverseWts(); //Ordinarily, the graph is directional - //this converts the graph into an + //this converts the graph into an //undirectional graph //This is done by adding an edge //v->u for all existing edges u->v @@ -325,31 +325,31 @@ public: //print graph: for debugging void printGraph(); - + //get a vector of back edges in the graph void getBackEdges(std::vector<Edge> &be, std::map<Node *, int> &d); nodeList &sortNodeList(Node *par, nodeList &nl, std::vector<Edge> &be); - + //Get the Maximal spanning tree (also a graph) //of the graph Graph* getMaxSpanningTree(); - + //get the nodeList adjacent to a node - //a nodeList element contains a node, and the weight + //a nodeList element contains a node, and the weight //corresponding to the edge for that element inline nodeList &getNodeList(Node *nd) { elementIterator nli = nodes.find(nd); assert(nli != nodes.end() && "Node must be in nodes map"); return nodes[nd];//sortNodeList(nd, nli->second); } - + nodeList &getSortedNodeList(Node *nd, std::vector<Edge> &be) { elementIterator nli = nodes.find(nd); assert(nli != nodes.end() && "Node must be in nodes map"); return sortNodeList(nd, nodes[nd], be); } - + //get the root of the graph inline Node *getRoot() {return strt; } inline Node * const getRoot() const {return strt; } @@ -365,7 +365,7 @@ public: inline bool isLeaf(Node *n) const {return (*n==*ext); } }; -//This class is used to generate +//This class is used to generate //"appropriate" code to be inserted //along an edge //The code to be inserted can be of six different types @@ -378,13 +378,13 @@ public: //6: Count[r]++ class getEdgeCode{ private: - //cond implies which + //cond implies which //"kind" of code is to be inserted //(from 1-6 above) int cond; //inc is the increment: eg k, or 0 int inc; - + //A backedge must carry the code //of both incoming "dummy" edge //and outgoing "dummy" edge @@ -420,23 +420,23 @@ public: //set CdIn (only used for backedges) inline void setCdIn(getEdgeCode *gd){ cdIn=gd;} - + //set CdOut (only used for backedges) inline void setCdOut(getEdgeCode *gd){ cdOut=gd;} //get the code to be inserted on the edge //This is determined from cond (1-6) - void getCode(Instruction *a, Value *b, Function *M, BasicBlock *BB, + void getCode(Instruction *a, Value *b, Function *M, BasicBlock *BB, std::vector<Value *> &retVec); }; //auxillary functions on graph -//print a given edge in the form BB1Label->BB2Label +//print a given edge in the form BB1Label->BB2Label void printEdge(Edge ed); -//Do graph processing: to determine minimal edge increments, +//Do graph processing: to determine minimal edge increments, //appropriate code insertions etc and insert the code at //appropriate locations void processGraph(Graph &g, Instruction *rInst, Value *countInst, std::vector<Edge> &be, std::vector<Edge> &stDummy, std::vector<Edge> &exDummy, int n, int MethNo, Value *threshold); @@ -452,7 +452,7 @@ void insertBB(Edge ed, getEdgeCode *edgeCode, Instruction *rInst, Value *countIn //Insert the initialization code in the top BB //this includes initializing r, and count -//r is like an accumulator, that +//r is like an accumulator, that //keeps on adding increments as we traverse along a path //and at the end of the path, r contains the path //number of that path @@ -470,7 +470,7 @@ void addDummyEdges(std::vector<Edge> &stDummy, std::vector<Edge> &exDummy, Graph //such that if we traverse along any path from root to exit, and //add up the edge values, we get a path number that uniquely //refers to the path we travelled -int valueAssignmentToEdges(Graph& g, std::map<Node *, int> nodePriority, +int valueAssignmentToEdges(Graph& g, std::map<Node *, int> nodePriority, std::vector<Edge> &be); void getBBtrace(std::vector<BasicBlock *> &vBB, int pathNo, Function *M); diff --git a/lib/Transforms/Instrumentation/ProfilePaths/GraphAuxiliary.cpp b/lib/Transforms/Instrumentation/ProfilePaths/GraphAuxiliary.cpp index bd1fa51..bd7bf4f 100644 --- a/lib/Transforms/Instrumentation/ProfilePaths/GraphAuxiliary.cpp +++ b/lib/Transforms/Instrumentation/ProfilePaths/GraphAuxiliary.cpp @@ -1,10 +1,10 @@ //===- GraphAuxiliary.cpp - Auxiliary functions on graph ------------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // auxiliary function associated with graph: they all operate on graph, and help @@ -36,10 +36,10 @@ static void getChords(vector<Edge > &chords, Graph &g, Graph st){ //make sure the spanning tree is directional //iterate over ALL the edges of the graph vector<Node *> allNodes=g.getAllNodes(); - for(vector<Node *>::iterator NI=allNodes.begin(), NE=allNodes.end(); NI!=NE; + for(vector<Node *>::iterator NI=allNodes.begin(), NE=allNodes.end(); NI!=NE; ++NI){ Graph::nodeList node_list=g.getNodeList(*NI); - for(Graph::nodeList::iterator NLI=node_list.begin(), NLE=node_list.end(); + for(Graph::nodeList::iterator NLI=node_list.begin(), NLE=node_list.end(); NLI!=NLE; ++NLI){ Edge f(*NI, NLI->element,NLI->weight, NLI->randId); if(!(st.hasEdgeAndWt(f)))//addnl @@ -51,13 +51,13 @@ static void getChords(vector<Edge > &chords, Graph &g, Graph st){ //Given a tree t, and a "directed graph" g //replace the edges in the tree t with edges that exist in graph //The tree is formed from "undirectional" copy of graph -//So whatever edges the tree has, the undirectional graph -//would have too. This function corrects some of the directions in +//So whatever edges the tree has, the undirectional graph +//would have too. This function corrects some of the directions in //the tree so that now, all edge directions in the tree match //the edge directions of corresponding edges in the directed graph static void removeTreeEdges(Graph &g, Graph& t){ vector<Node* > allNodes=t.getAllNodes(); - for(vector<Node *>::iterator NI=allNodes.begin(), NE=allNodes.end(); NI!=NE; + for(vector<Node *>::iterator NI=allNodes.begin(), NE=allNodes.end(); NI!=NE; ++NI){ Graph::nodeList nl=t.getNodeList(*NI); for(Graph::nodeList::iterator NLI=nl.begin(), NLE=nl.end(); NLI!=NLE;++NLI){ @@ -72,11 +72,11 @@ static void removeTreeEdges(Graph &g, Graph& t){ //such that if we traverse along any path from root to exit, and //add up the edge values, we get a path number that uniquely //refers to the path we travelled -int valueAssignmentToEdges(Graph& g, map<Node *, int> nodePriority, +int valueAssignmentToEdges(Graph& g, map<Node *, int> nodePriority, vector<Edge> &be){ vector<Node *> revtop=g.reverseTopologicalSort(); map<Node *,int > NumPaths; - for(vector<Node *>::iterator RI=revtop.begin(), RE=revtop.end(); + for(vector<Node *>::iterator RI=revtop.begin(), RE=revtop.end(); RI!=RE; ++RI){ if(g.isLeaf(*RI)) NumPaths[*RI]=1; @@ -87,47 +87,47 @@ int valueAssignmentToEdges(Graph& g, map<Node *, int> nodePriority, Graph::nodeList &nlist=g.getSortedNodeList(*RI, be); //sort nodelist by increasing order of numpaths - + int sz=nlist.size(); - + for(int i=0;i<sz-1; i++){ int min=i; for(int j=i+1; j<sz; j++){ BasicBlock *bb1 = nlist[j].element->getElement(); BasicBlock *bb2 = nlist[min].element->getElement(); - + if(bb1 == bb2) continue; - + if(*RI == g.getRoot()){ - assert(nodePriority[nlist[min].element]!= - nodePriority[nlist[j].element] + assert(nodePriority[nlist[min].element]!= + nodePriority[nlist[j].element] && "priorities can't be same!"); - - if(nodePriority[nlist[j].element] < + + if(nodePriority[nlist[j].element] < nodePriority[nlist[min].element]) - min = j; + min = j; } else{ TerminatorInst *tti = (*RI)->getElement()->getTerminator(); - + BranchInst *ti = cast<BranchInst>(tti); assert(ti && "not a branch"); assert(ti->getNumSuccessors()==2 && "less successors!"); - + BasicBlock *tB = ti->getSuccessor(0); BasicBlock *fB = ti->getSuccessor(1); - + if(tB == bb1 || fB == bb2) min = j; } - + } graphListElement tempEl=nlist[min]; nlist[min]=nlist[i]; nlist[i]=tempEl; } - + //sorted now! for(Graph::nodeList::iterator GLI=nlist.begin(), GLE=nlist.end(); GLI!=GLE; ++GLI){ @@ -148,35 +148,35 @@ int valueAssignmentToEdges(Graph& g, map<Node *, int> nodePriority, //refers to the path we travelled //inc_Dir tells whether 2 edges are in same, or in different directions //if same direction, return 1, else -1 -static int inc_Dir(Edge e, Edge f){ - if(e.isNull()) +static int inc_Dir(Edge e, Edge f){ + if(e.isNull()) return 1; - + //check that the edges must have at least one common endpoint assert(*(e.getFirst())==*(f.getFirst()) || - *(e.getFirst())==*(f.getSecond()) || + *(e.getFirst())==*(f.getSecond()) || *(e.getSecond())==*(f.getFirst()) || *(e.getSecond())==*(f.getSecond())); - if(*(e.getFirst())==*(f.getSecond()) || + if(*(e.getFirst())==*(f.getSecond()) || *(e.getSecond())==*(f.getFirst())) return 1; - + return -1; } //used for getting edge increments (read comments above in inc_Dir) -//inc_DFS is a modification of DFS -static void inc_DFS(Graph& g,Graph& t,map<Edge, int, EdgeCompare2>& Increment, +//inc_DFS is a modification of DFS +static void inc_DFS(Graph& g,Graph& t,map<Edge, int, EdgeCompare2>& Increment, int events, Node *v, Edge e){ - + vector<Node *> allNodes=t.getAllNodes(); - for(vector<Node *>::iterator NI=allNodes.begin(), NE=allNodes.end(); NI!=NE; + for(vector<Node *>::iterator NI=allNodes.begin(), NE=allNodes.end(); NI!=NE; ++NI){ Graph::nodeList node_list=t.getNodeList(*NI); - for(Graph::nodeList::iterator NLI=node_list.begin(), NLE=node_list.end(); + for(Graph::nodeList::iterator NLI=node_list.begin(), NLE=node_list.end(); NLI!= NLE; ++NLI){ Edge f(*NI, NLI->element,NLI->weight, NLI->randId); if(!edgesEqual(f,e) && *v==*(f.getSecond())){ @@ -187,29 +187,29 @@ static void inc_DFS(Graph& g,Graph& t,map<Edge, int, EdgeCompare2>& Increment, } } - for(vector<Node *>::iterator NI=allNodes.begin(), NE=allNodes.end(); NI!=NE; + for(vector<Node *>::iterator NI=allNodes.begin(), NE=allNodes.end(); NI!=NE; ++NI){ Graph::nodeList node_list=t.getNodeList(*NI); - for(Graph::nodeList::iterator NLI=node_list.begin(), NLE=node_list.end(); + for(Graph::nodeList::iterator NLI=node_list.begin(), NLE=node_list.end(); NLI!=NLE; ++NLI){ Edge f(*NI, NLI->element,NLI->weight, NLI->randId); if(!edgesEqual(f,e) && *v==*(f.getFirst())){ int dir_count=inc_Dir(e,f); int wt=f.getWeight(); - inc_DFS(g,t, Increment, dir_count*events+wt, + inc_DFS(g,t, Increment, dir_count*events+wt, f.getSecond(), f); } } } allNodes=g.getAllNodes(); - for(vector<Node *>::iterator NI=allNodes.begin(), NE=allNodes.end(); NI!=NE; + for(vector<Node *>::iterator NI=allNodes.begin(), NE=allNodes.end(); NI!=NE; ++NI){ Graph::nodeList node_list=g.getNodeList(*NI); - for(Graph::nodeList::iterator NLI=node_list.begin(), NLE=node_list.end(); + for(Graph::nodeList::iterator NLI=node_list.begin(), NLE=node_list.end(); NLI!=NLE; ++NLI){ Edge f(*NI, NLI->element,NLI->weight, NLI->randId); - if(!(t.hasEdgeAndWt(f)) && (*v==*(f.getSecond()) || + if(!(t.hasEdgeAndWt(f)) && (*v==*(f.getSecond()) || *v==*(f.getFirst()))){ int dir_count=inc_Dir(e,f); Increment[f]+=dir_count*events; @@ -219,21 +219,21 @@ static void inc_DFS(Graph& g,Graph& t,map<Edge, int, EdgeCompare2>& Increment, } //Now we select a subset of all edges -//and assign them some values such that +//and assign them some values such that //if we consider just this subset, it still represents //the path sum along any path in the graph -static map<Edge, int, EdgeCompare2> getEdgeIncrements(Graph& g, Graph& t, +static map<Edge, int, EdgeCompare2> getEdgeIncrements(Graph& g, Graph& t, vector<Edge> &be){ //get all edges in g-t map<Edge, int, EdgeCompare2> Increment; vector<Node *> allNodes=g.getAllNodes(); - - for(vector<Node *>::iterator NI=allNodes.begin(), NE=allNodes.end(); NI!=NE; + + for(vector<Node *>::iterator NI=allNodes.begin(), NE=allNodes.end(); NI!=NE; ++NI){ Graph::nodeList node_list=g.getSortedNodeList(*NI, be); //modified g.getNodeList(*NI); - for(Graph::nodeList::iterator NLI=node_list.begin(), NLE=node_list.end(); + for(Graph::nodeList::iterator NLI=node_list.begin(), NLE=node_list.end(); NLI!=NLE; ++NLI){ Edge ed(*NI, NLI->element,NLI->weight,NLI->randId); if(!(t.hasEdgeAndWt(ed))){ @@ -245,11 +245,11 @@ static map<Edge, int, EdgeCompare2> getEdgeIncrements(Graph& g, Graph& t, Edge *ed=new Edge(); inc_DFS(g,t,Increment, 0, g.getRoot(), *ed); - for(vector<Node *>::iterator NI=allNodes.begin(), NE=allNodes.end(); NI!=NE; + for(vector<Node *>::iterator NI=allNodes.begin(), NE=allNodes.end(); NI!=NE; ++NI){ Graph::nodeList node_list=g.getSortedNodeList(*NI, be); //modified g.getNodeList(*NI); - for(Graph::nodeList::iterator NLI=node_list.begin(), NLE=node_list.end(); + for(Graph::nodeList::iterator NLI=node_list.begin(), NLE=node_list.end(); NLI!=NLE; ++NLI){ Edge ed(*NI, NLI->element,NLI->weight, NLI->randId); if(!(t.hasEdgeAndWt(ed))){ @@ -274,7 +274,7 @@ graphListElement *findNodeInList(Graph::nodeList &NL, Node *N); //The idea here is to minimize the computation //by inserting only the needed code static void getCodeInsertions(Graph &g, map<Edge, getEdgeCode *, EdgeCompare2> &instr, - vector<Edge > &chords, + vector<Edge > &chords, map<Edge,int, EdgeCompare2> &edIncrements){ //Register initialization code @@ -285,7 +285,7 @@ static void getCodeInsertions(Graph &g, map<Edge, getEdgeCode *, EdgeCompare2> & ws.pop_back(); //for each edge v->w Graph::nodeList succs=g.getNodeList(v); - + for(Graph::nodeList::iterator nl=succs.begin(), ne=succs.end(); nl!=ne; ++nl){ int edgeWt=nl->weight; @@ -320,7 +320,7 @@ static void getCodeInsertions(Graph &g, map<Edge, getEdgeCode *, EdgeCompare2> & /////Memory increment code ws.push_back(g.getExit()); - + while(!ws.empty()) { Node *w=ws.back(); ws.pop_back(); @@ -333,11 +333,11 @@ static void getCodeInsertions(Graph &g, map<Edge, getEdgeCode *, EdgeCompare2> & Node *lnode=*EII; Graph::nodeList &nl = g.getNodeList(lnode); //graphListElement *N = findNodeInList(nl, w); - for(Graph::nodeList::const_iterator N = nl.begin(), + for(Graph::nodeList::const_iterator N = nl.begin(), NNEN = nl.end(); N!= NNEN; ++N){ if (*N->element == *w){ Node *v=lnode; - + //if chords has v->w Edge ed(v,w, N->weight, N->randId); getEdgeCode *edCd=new getEdgeCode(); @@ -359,7 +359,7 @@ static void getCodeInsertions(Graph &g, map<Edge, getEdgeCode *, EdgeCompare2> & edCd->setInc(edIncrements[ed]); instr[ed]=edCd; } - + } else if(g.getNumberOfOutgoingEdges(v)==1) ws.push_back(v); @@ -387,8 +387,8 @@ static void getCodeInsertions(Graph &g, map<Edge, getEdgeCode *, EdgeCompare2> & //then incoming dummy edge is root->b //and outgoing dummy edge is a->exit //changed -void addDummyEdges(vector<Edge > &stDummy, - vector<Edge > &exDummy, +void addDummyEdges(vector<Edge > &stDummy, + vector<Edge > &exDummy, Graph &g, vector<Edge> &be){ for(vector<Edge >::iterator VI=be.begin(), VE=be.end(); VI!=VE; ++VI){ Edge ed=*VI; @@ -420,17 +420,17 @@ void printEdge(Edge ed){ //Move the incoming dummy edge code and outgoing dummy //edge code over to the corresponding back edge -static void moveDummyCode(vector<Edge> &stDummy, - vector<Edge> &exDummy, - vector<Edge> &be, - map<Edge, getEdgeCode *, EdgeCompare2> &insertions, +static void moveDummyCode(vector<Edge> &stDummy, + vector<Edge> &exDummy, + vector<Edge> &be, + map<Edge, getEdgeCode *, EdgeCompare2> &insertions, Graph &g){ typedef vector<Edge >::iterator vec_iter; - + map<Edge,getEdgeCode *, EdgeCompare2> temp; //iterate over edges with code std::vector<Edge> toErase; - for(map<Edge,getEdgeCode *, EdgeCompare2>::iterator MI=insertions.begin(), + for(map<Edge,getEdgeCode *, EdgeCompare2>::iterator MI=insertions.begin(), ME=insertions.end(); MI!=ME; ++MI){ Edge ed=MI->first; getEdgeCode *edCd=MI->second; @@ -462,18 +462,18 @@ static void moveDummyCode(vector<Edge> &stDummy, } } } - - for(vector<Edge >::iterator vmi=toErase.begin(), vme=toErase.end(); vmi!=vme; + + for(vector<Edge >::iterator vmi=toErase.begin(), vme=toErase.end(); vmi!=vme; ++vmi){ insertions.erase(*vmi); g.removeEdgeWithWt(*vmi); } - - for(map<Edge,getEdgeCode *, EdgeCompare2>::iterator MI=temp.begin(), + + for(map<Edge,getEdgeCode *, EdgeCompare2>::iterator MI=temp.begin(), ME=temp.end(); MI!=ME; ++MI){ insertions[MI->first]=MI->second; } - + #ifdef DEBUG_PATH_PROFILES cerr<<"size of deletions: "<<toErase.size()<<"\n"; cerr<<"SIZE OF INSERTIONS AFTER DEL "<<insertions.size()<<"\n"; @@ -481,16 +481,16 @@ static void moveDummyCode(vector<Edge> &stDummy, } -//Do graph processing: to determine minimal edge increments, +//Do graph processing: to determine minimal edge increments, //appropriate code insertions etc and insert the code at //appropriate locations -void processGraph(Graph &g, - Instruction *rInst, - Value *countInst, - vector<Edge >& be, - vector<Edge >& stDummy, - vector<Edge >& exDummy, - int numPaths, int MethNo, +void processGraph(Graph &g, + Instruction *rInst, + Value *countInst, + vector<Edge >& be, + vector<Edge >& stDummy, + vector<Edge >& exDummy, + int numPaths, int MethNo, Value *threshold){ //Given a graph: with exit->root edge, do the following in seq: @@ -505,11 +505,11 @@ void processGraph(Graph &g, //5. Get edge increments //6. Get code insertions //7. move code on dummy edges over to the back edges - - //This is used as maximum "weight" for + + //This is used as maximum "weight" for //priority queue - //This would hold all + //This would hold all //right as long as number of paths in the graph //is less than this const int Infinity=99999999; @@ -524,7 +524,7 @@ void processGraph(Graph &g, //if its there earlier, remove it! //assign it weight Infinity //so that this edge IS ALWAYS IN spanning tree - //Note than edges in spanning tree do not get + //Note than edges in spanning tree do not get //instrumented: and we do not want the //edge exit->root to get instrumented //as it MAY BE a dummy edge @@ -544,13 +544,13 @@ void processGraph(Graph &g, #endif //now edges of tree t have weights reversed //(negative) because the algorithm used - //to find max spanning tree is + //to find max spanning tree is //actually for finding min spanning tree //so get back the original weights t->reverseWts(); //Ordinarily, the graph is directional - //lets converts the graph into an + //lets converts the graph into an //undirectional graph //This is done by adding an edge //v->u for all existing edges u->v @@ -559,8 +559,8 @@ void processGraph(Graph &g, //Given a tree t, and a "directed graph" g //replace the edges in the tree t with edges that exist in graph //The tree is formed from "undirectional" copy of graph - //So whatever edges the tree has, the undirectional graph - //would have too. This function corrects some of the directions in + //So whatever edges the tree has, the undirectional graph + //would have too. This function corrects some of the directions in //the tree so that now, all edge directions in the tree match //the edge directions of corresponding edges in the directed graph removeTreeEdges(g, *t); @@ -588,7 +588,7 @@ void processGraph(Graph &g, //step 5: Get edge increments //Now we select a subset of all edges - //and assign them some values such that + //and assign them some values such that //if we consider just this subset, it still represents //the path sum along any path in the graph @@ -603,9 +603,9 @@ void processGraph(Graph &g, std::cerr<<"-------end of edge increments\n"; #endif - + //step 6: Get code insertions - + //Based on edgeIncrements (above), now obtain //the kind of code to be inserted along an edge //The idea here is to minimize the computation @@ -616,11 +616,11 @@ void processGraph(Graph &g, map<Edge, getEdgeCode *, EdgeCompare2> codeInsertions; getCodeInsertions(g, codeInsertions, chords,increment); - + #ifdef DEBUG_PATH_PROFILES //print edges with code for debugging cerr<<"Code inserted in following---------------\n"; - for(map<Edge, getEdgeCode *, EdgeCompare2>::iterator cd_i=codeInsertions.begin(), + for(map<Edge, getEdgeCode *, EdgeCompare2>::iterator cd_i=codeInsertions.begin(), cd_e=codeInsertions.end(); cd_i!=cd_e; ++cd_i){ printEdge(cd_i->first); cerr<<cd_i->second->getCond()<<":"<<cd_i->second->getInc()<<"\n"; @@ -634,11 +634,11 @@ void processGraph(Graph &g, //edge code over to the corresponding back edge moveDummyCode(stDummy, exDummy, be, codeInsertions, g); - + #ifdef DEBUG_PATH_PROFILES //debugging info cerr<<"After moving dummy code\n"; - for(map<Edge, getEdgeCode *,EdgeCompare2>::iterator cd_i=codeInsertions.begin(), + for(map<Edge, getEdgeCode *,EdgeCompare2>::iterator cd_i=codeInsertions.begin(), cd_e=codeInsertions.end(); cd_i != cd_e; ++cd_i){ printEdge(cd_i->first); cerr<<cd_i->second->getCond()<<":" @@ -650,22 +650,22 @@ void processGraph(Graph &g, //see what it looks like... //now insert code along edges which have codes on them - for(map<Edge, getEdgeCode *,EdgeCompare2>::iterator MI=codeInsertions.begin(), + for(map<Edge, getEdgeCode *,EdgeCompare2>::iterator MI=codeInsertions.begin(), ME=codeInsertions.end(); MI!=ME; ++MI){ Edge ed=MI->first; insertBB(ed, MI->second, rInst, countInst, numPaths, MethNo, threshold); - } + } } //print the graph (for debugging) void printGraph(Graph &g){ vector<Node *> lt=g.getAllNodes(); cerr<<"Graph---------------------\n"; - for(vector<Node *>::iterator LI=lt.begin(); + for(vector<Node *>::iterator LI=lt.begin(); LI!=lt.end(); ++LI){ cerr<<((*LI)->getElement())->getName()<<"->"; Graph::nodeList nl=g.getNodeList(*LI); - for(Graph::nodeList::iterator NI=nl.begin(); + for(Graph::nodeList::iterator NI=nl.begin(); NI!=nl.end(); ++NI){ cerr<<":"<<"("<<(NI->element->getElement()) ->getName()<<":"<<NI->element->getWeight()<<","<<NI->weight<<"," diff --git a/lib/Transforms/Instrumentation/ProfilePaths/InstLoops.cpp b/lib/Transforms/Instrumentation/ProfilePaths/InstLoops.cpp index 5002087..fc82897 100644 --- a/lib/Transforms/Instrumentation/ProfilePaths/InstLoops.cpp +++ b/lib/Transforms/Instrumentation/ProfilePaths/InstLoops.cpp @@ -1,10 +1,10 @@ //===-- InstLoops.cpp -----------------------------------------------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This is the first-level instrumentation pass for the Reoptimizer. It @@ -46,7 +46,7 @@ namespace { DominatorSet *DS; void getBackEdgesVisit(BasicBlock *u, std::map<BasicBlock *, Color > &color, - std::map<BasicBlock *, int > &d, + std::map<BasicBlock *, int > &d, int &time, BBMap &be); void removeRedundant(BBMap &be); void findAndInstrumentBackEdges(Function &F); @@ -54,15 +54,15 @@ namespace { bool doInitialization(Module &M); bool runOnFunction(Function &F); }; - + RegisterOpt<InstLoops> X("instloops", "Instrument backedges for profiling"); } -//helper function to get back edges: it is called by +//helper function to get back edges: it is called by //the "getBackEdges" function below void InstLoops::getBackEdgesVisit(BasicBlock *u, std::map<BasicBlock *, Color > &color, - std::map<BasicBlock *, int > &d, + std::map<BasicBlock *, int > &d, int &time, BBMap &be) { color[u]=GREY; time++; @@ -74,7 +74,7 @@ void InstLoops::getBackEdgesVisit(BasicBlock *u, if(color[BB]!=GREY && color[BB]!=BLACK){ getBackEdgesVisit(BB, color, d, time, be); } - + //now checking for d and f vals else if(color[BB]==GREY){ //so v is ancestor of u if time of u > time of v @@ -91,13 +91,13 @@ void InstLoops::getBackEdgesVisit(BasicBlock *u, //set void InstLoops::removeRedundant(BBMap &be) { std::vector<BasicBlock *> toDelete; - for(std::map<BasicBlock *, BasicBlock *>::iterator MI = be.begin(), + for(std::map<BasicBlock *, BasicBlock *>::iterator MI = be.begin(), ME = be.end(); MI != ME; ++MI) for(BBMap::iterator MMI = be.begin(), MME = be.end(); MMI != MME; ++MMI) if(DS->properlyDominates(MI->first, MMI->first)) toDelete.push_back(MMI->first); // Remove all the back-edges we found from be. - for(std::vector<BasicBlock *>::iterator VI = toDelete.begin(), + for(std::vector<BasicBlock *>::iterator VI = toDelete.begin(), VE = toDelete.end(); VI != VE; ++VI) be.erase(*VI); } @@ -137,14 +137,14 @@ void InstLoops::findAndInstrumentBackEdges(Function &F){ assert(ti->getNumSuccessors() > index && "Not enough successors!"); ti->setSuccessor(index, newBB); - + BasicBlock::InstListType < = newBB->getInstList(); lt.push_back(new CallInst(inCountMth)); new BranchInst(BB, newBB); - + // Now, set the sources of Phi nodes corresponding to the back-edge // in BB to come from the instrumentation block instead. - for(BasicBlock::iterator BB2Inst = BB->begin(), BBend = BB->end(); + for(BasicBlock::iterator BB2Inst = BB->begin(), BBend = BB->end(); BB2Inst != BBend; ++BB2Inst) { if (PHINode *phiInst = dyn_cast<PHINode>(BB2Inst)) { int bbIndex = phiInst->getBasicBlockIndex(u); diff --git a/lib/Transforms/Instrumentation/ProfilePaths/ProfilePaths.cpp b/lib/Transforms/Instrumentation/ProfilePaths/ProfilePaths.cpp index cc14c268..d0d0f55 100644 --- a/lib/Transforms/Instrumentation/ProfilePaths/ProfilePaths.cpp +++ b/lib/Transforms/Instrumentation/ProfilePaths/ProfilePaths.cpp @@ -1,17 +1,17 @@ //===-- ProfilePaths.cpp - interface to insert instrumentation --*- C++ -*-===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This inserts instrumentation for counting execution of paths though a given // function Its implemented as a "Function" Pass, and called using opt // -// This pass is implemented by using algorithms similar to -// 1."Efficient Path Profiling": Ball, T. and Larus, J. R., +// This pass is implemented by using algorithms similar to +// 1."Efficient Path Profiling": Ball, T. and Larus, J. R., // Proceedings of Micro-29, Dec 1996, Paris, France. // 2."Efficiently Counting Program events with support for on-line // "queries": Ball T., ACM Transactions on Programming Languages @@ -22,7 +22,7 @@ // (implementation in Graph.cpp and GraphAuxiliary.cpp) and finally, appropriate // instrumentation is placed over suitable edges. (code inserted through // EdgeCode.cpp). -// +// // The algorithm inserts code such that every acyclic path in the CFG of a // function is identified through a unique number. the code insertion is optimal // in the sense that its inserted over a minimal set of edges. Also, the @@ -47,7 +47,7 @@ namespace llvm { struct ProfilePaths : public FunctionPass { bool runOnFunction(Function &F); - // Before this pass, make sure that there is only one + // Before this pass, make sure that there is only one // entry and only one exit node for the function in the CFG of the function // void getAnalysisUsage(AnalysisUsage &AU) const { @@ -76,13 +76,13 @@ bool ProfilePaths::runOnFunction(Function &F){ if(F.isExternal()) { return false; } - + //increment counter for instrumented functions. mn is now function# mn++; - + // Transform the cfg s.t. we have just one exit node - BasicBlock *ExitNode = - getAnalysis<UnifyFunctionExitNodes>().getReturnBlock(); + BasicBlock *ExitNode = + getAnalysis<UnifyFunctionExitNodes>().getReturnBlock(); //iterating over BBs and making graph std::vector<Node *> nodes; @@ -92,10 +92,10 @@ bool ProfilePaths::runOnFunction(Function &F){ // The nodes must be uniquely identified: // That is, no two nodes must hav same BB* - + for (Function::iterator BB = F.begin(), BE = F.end(); BB != BE; ++BB) { Node *nd=new Node(BB); - nodes.push_back(nd); + nodes.push_back(nd); if(&*BB == ExitNode) exitNode=nd; if(BB==F.begin()) @@ -114,22 +114,22 @@ bool ProfilePaths::runOnFunction(Function &F){ edges.push_back(ed); } } - + Graph g(nodes,edges, startNode, exitNode); -#ifdef DEBUG_PATH_PROFILES +#ifdef DEBUG_PATH_PROFILES std::cerr<<"Original graph\n"; printGraph(g); #endif BasicBlock *fr = &F.front(); - + // The graph is made acyclic: this is done // by removing back edges for now, and adding them later on std::vector<Edge> be; std::map<Node *, int> nodePriority; //it ranks nodes in depth first order traversal g.getBackEdges(be, nodePriority); - + #ifdef DEBUG_PATH_PROFILES std::cerr<<"BackEdges-------------\n"; for (std::vector<Edge>::iterator VI=be.begin(); VI!=be.end(); ++VI){ @@ -190,7 +190,7 @@ bool ProfilePaths::runOnFunction(Function &F){ Function *initialize = F.getParent()->getOrInsertFunction("reoptimizerInitialize", Type::VoidTy, PointerType::get(Type::IntTy), 0); - + std::vector<Value *> trargs; trargs.push_back(threshold); new CallInst(initialize, trargs, "", fr->begin()); @@ -198,8 +198,8 @@ bool ProfilePaths::runOnFunction(Function &F){ if(numPaths<=1 || numPaths >5000) return false; - -#ifdef DEBUG_PATH_PROFILES + +#ifdef DEBUG_PATH_PROFILES printGraph(g); #endif @@ -210,12 +210,12 @@ bool ProfilePaths::runOnFunction(Function &F){ //count is an array: count[x] would store //the number of executions of path numbered x - Instruction *rVar=new - AllocaInst(Type::IntTy, + Instruction *rVar=new + AllocaInst(Type::IntTy, ConstantUInt::get(Type::UIntTy,1),"R"); - //Instruction *countVar=new - //AllocaInst(Type::IntTy, + //Instruction *countVar=new + //AllocaInst(Type::IntTy, // ConstantUInt::get(Type::UIntTy, numPaths), "Count"); //initialize counter array! @@ -230,21 +230,21 @@ bool ProfilePaths::runOnFunction(Function &F){ CountCounter++; std::string countStr = tempChar; GlobalVariable *countVar = new GlobalVariable(ATy, false, - GlobalValue::InternalLinkage, + GlobalValue::InternalLinkage, initializer, countStr, F.getParent()); - + // insert initialization code in first (entry) BB // this includes initializing r and count insertInTopBB(&F.getEntryBlock(), numPaths, rVar, threshold); - + //now process the graph: get path numbers, //get increments along different paths, //and assign "increments" and "updates" (to r and count) //"optimally". Finally, insert llvm code along various edges - processGraph(g, rVar, countVar, be, stDummy, exDummy, numPaths, mn, - threshold); - + processGraph(g, rVar, countVar, be, stDummy, exDummy, numPaths, mn, + threshold); + return true; // Always modifies function } diff --git a/lib/Transforms/Instrumentation/ProfilePaths/RetracePath.cpp b/lib/Transforms/Instrumentation/ProfilePaths/RetracePath.cpp index 4954723..c920940 100644 --- a/lib/Transforms/Instrumentation/ProfilePaths/RetracePath.cpp +++ b/lib/Transforms/Instrumentation/ProfilePaths/RetracePath.cpp @@ -1,10 +1,10 @@ //===- RetracePath.cpp ----------------------------------------------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // Retraces a path of BasicBlock, given a path number and a graph! @@ -25,12 +25,12 @@ namespace llvm { //Routines to get the path trace! -void getPathFrmNode(Node *n, vector<BasicBlock*> &vBB, int pathNo, Graph &g, - vector<Edge> &stDummy, vector<Edge> &exDummy, +void getPathFrmNode(Node *n, vector<BasicBlock*> &vBB, int pathNo, Graph &g, + vector<Edge> &stDummy, vector<Edge> &exDummy, vector<Edge> &be, double strand){ Graph::nodeList &nlist = g.getNodeList(n); - + //printGraph(g); //std::cerr<<"Path No: "<<pathNo<<"\n"; int maxCount=-9999999; @@ -53,7 +53,7 @@ void getPathFrmNode(Node *n, vector<BasicBlock*> &vBB, int pathNo, Graph &g, } if(!isStart) - assert(strand!=-1 && "strand not assigned!"); + assert(strand!=-1 && "strand not assigned!"); assert(!(*nextRoot==*n && pathNo>0) && "No more BBs to go"); assert(!(*nextRoot==*g.getExit() && pathNo-maxCount!=0) && "Reached exit"); @@ -65,7 +65,7 @@ void getPathFrmNode(Node *n, vector<BasicBlock*> &vBB, int pathNo, Graph &g, //look for strnd and edgeRnd now: bool has1=false, has2=false; //check if exit has it - for(vector<Edge>::iterator VI=exDummy.begin(), VE=exDummy.end(); VI!=VE; + for(vector<Edge>::iterator VI=exDummy.begin(), VE=exDummy.end(); VI!=VE; ++VI){ if(VI->getRandId()==edgeRnd){ has2=true; @@ -74,7 +74,7 @@ void getPathFrmNode(Node *n, vector<BasicBlock*> &vBB, int pathNo, Graph &g, } //check if start has it - for(vector<Edge>::iterator VI=stDummy.begin(), VE=stDummy.end(); VI!=VE; + for(vector<Edge>::iterator VI=stDummy.begin(), VE=stDummy.end(); VI!=VE; ++VI){ if(VI->getRandId()==strand){ has1=true; @@ -98,22 +98,22 @@ void getPathFrmNode(Node *n, vector<BasicBlock*> &vBB, int pathNo, Graph &g, //find backedge with startpoint vBB[vBB.size()-1] for(vector<Edge>::iterator VI=be.begin(), VE=be.end(); VI!=VE; ++VI){ assert(vBB.size()>0 && "vector too small"); - if( VI->getFirst()->getElement() == vBB[vBB.size()-1] && + if( VI->getFirst()->getElement() == vBB[vBB.size()-1] && VI->getSecond()->getElement() == vBB[0]){ //vBB.push_back(VI->getSecond()->getElement()); break; } } } - else + else vBB.push_back(nextRoot->getElement()); - + return; } assert(pathNo-maxCount>=0); - return getPathFrmNode(nextRoot, vBB, pathNo-maxCount, g, stDummy, + return getPathFrmNode(nextRoot, vBB, pathNo-maxCount, g, stDummy, exDummy, be, strand); } @@ -131,16 +131,16 @@ void getBBtrace(vector<BasicBlock *> &vBB, int pathNo, Function *M){//, // vector<Instruction *> &instToErase){ //step 1: create graph //Transform the cfg s.t. we have just one exit node - + std::vector<Node *> nodes; std::vector<Edge> edges; Node *exitNode=0, *startNode=0; //Creat cfg just once for each function! - static std::map<Function *, Graph *> graphMap; + static std::map<Function *, Graph *> graphMap; //get backedges, exit and start edges for the graphs and store them - static std::map<Function *, vector<Edge> > stMap, exMap, beMap; + static std::map<Function *, vector<Edge> > stMap, exMap, beMap; static std::map<Function *, Value *> pathReg; //path register @@ -152,19 +152,19 @@ void getBBtrace(vector<BasicBlock *> &vBB, int pathNo, Function *M){//, break; } } - + assert(ExitNode!=0 && "exitnode not found"); - //iterating over BBs and making graph + //iterating over BBs and making graph //The nodes must be uniquely identified: //That is, no two nodes must hav same BB* - + //keep a map for trigger basicblocks! std::map<BasicBlock *, unsigned char> triggerBBs; //First enter just nodes: later enter edges for(Function::iterator BB = M->begin(), BE=M->end(); BB != BE; ++BB){ bool cont = false; - + if(BB->size()==3 || BB->size() ==2){ for(BasicBlock::iterator II = BB->begin(), IE = BB->end(); II != IE; ++II){ @@ -180,10 +180,10 @@ void getBBtrace(vector<BasicBlock *> &vBB, int pathNo, Function *M){//, } } } - + if(cont) continue; - + // const Instruction *inst = BB->getInstList().begin(); // if(isa<CallInst>(inst)){ // Instruction *ii1 = BB->getInstList().begin(); @@ -191,9 +191,9 @@ void getBBtrace(vector<BasicBlock *> &vBB, int pathNo, Function *M){//, // if(callInst->getCalledFunction()->getName()=="trigger") // continue; // } - + Node *nd=new Node(BB); - nodes.push_back(nd); + nodes.push_back(nd); if(&*BB==ExitNode) exitNode=nd; if(&*BB==&M->front()) @@ -201,16 +201,16 @@ void getBBtrace(vector<BasicBlock *> &vBB, int pathNo, Function *M){//, } assert(exitNode!=0 && startNode!=0 && "Start or exit not found!"); - + for (Function::iterator BB = M->begin(), BE=M->end(); BB != BE; ++BB){ - if(triggerBBs[BB] == 9) + if(triggerBBs[BB] == 9) continue; - + //if(BB->size()==3) //if(CallInst *callInst = dyn_cast<CallInst>(BB->getInstList().begin())) //if(callInst->getCalledFunction()->getName() == "trigger") //continue; - + // if(BB->size()==2){ // const Instruction *inst = BB->getInstList().begin(); // if(isa<CallInst>(inst)){ @@ -220,12 +220,12 @@ void getBBtrace(vector<BasicBlock *> &vBB, int pathNo, Function *M){//, // continue; // } // } - + Node *nd=findBB(nodes, BB); assert(nd && "No node for this edge!"); - + for(succ_iterator s=succ_begin(BB), se=succ_end(BB); s!=se; ++s){ - + if(triggerBBs[*s] == 9){ //if(!pathReg[M]){ //Get the path register for this! //if(BB->size()>8) @@ -235,11 +235,11 @@ void getBBtrace(vector<BasicBlock *> &vBB, int pathNo, Function *M){//, continue; } //if((*s)->size()==3) - //if(CallInst *callInst = + //if(CallInst *callInst = // dyn_cast<CallInst>((*s)->getInstList().begin())) // if(callInst->getCalledFunction()->getName() == "trigger") // continue; - + // if((*s)->size()==2){ // const Instruction *inst = (*s)->getInstList().begin(); // if(isa<CallInst>(inst)){ @@ -249,40 +249,40 @@ void getBBtrace(vector<BasicBlock *> &vBB, int pathNo, Function *M){//, // continue; // } // } - + Node *nd2 = findBB(nodes,*s); assert(nd2 && "No node for this edge!"); Edge ed(nd,nd2,0); edges.push_back(ed); } } - + graphMap[M]= new Graph(nodes,edges, startNode, exitNode); - + Graph *g = graphMap[M]; - if (M->size() <= 1) return; //uninstrumented - + if (M->size() <= 1) return; //uninstrumented + //step 2: getBackEdges //vector<Edge> be; std::map<Node *, int> nodePriority; g->getBackEdges(beMap[M], nodePriority); - + //step 3: add dummy edges //vector<Edge> stDummy; //vector<Edge> exDummy; addDummyEdges(stMap[M], exMap[M], *g, beMap[M]); - + //step 4: value assgn to edges int numPaths = valueAssignmentToEdges(*g, nodePriority, beMap[M]); } - - - //step 5: now travel from root, select max(edge) < pathNo, + + + //step 5: now travel from root, select max(edge) < pathNo, //and go on until reach the exit - getPathFrmNode(graphMap[M]->getRoot(), vBB, pathNo, *graphMap[M], + getPathFrmNode(graphMap[M]->getRoot(), vBB, pathNo, *graphMap[M], stMap[M], exMap[M], beMap[M], -1); - + //post process vBB to locate instructions to be erased /* diff --git a/lib/Transforms/Instrumentation/ProfilingUtils.cpp b/lib/Transforms/Instrumentation/ProfilingUtils.cpp index 5ce0142..4093759 100644 --- a/lib/Transforms/Instrumentation/ProfilingUtils.cpp +++ b/lib/Transforms/Instrumentation/ProfilingUtils.cpp @@ -1,10 +1,10 @@ //===- ProfilingUtils.cpp - Helper functions shared by profilers ----------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This files implements a few helper functions which are used by profile @@ -51,7 +51,7 @@ void llvm::InsertProfilingInitCall(Function *MainFn, const char *FnName, Args[2] = ConstantPointerNull::get(UIntPtr); } Args[3] = ConstantUInt::get(Type::UIntTy, NumElements); - + Instruction *InitCall = new CallInst(InitFn, Args, "newargc", InsertPos); // If argc or argv are not available in main, just pass null values in. @@ -80,7 +80,7 @@ void llvm::InsertProfilingInitCall(Function *MainFn, const char *FnName, AI->replaceAllUsesWith(InitCall); InitCall->setOperand(1, AI); } - + case 0: break; } } diff --git a/lib/Transforms/Instrumentation/ProfilingUtils.h b/lib/Transforms/Instrumentation/ProfilingUtils.h index cf1bbce..52c6e04 100644 --- a/lib/Transforms/Instrumentation/ProfilingUtils.h +++ b/lib/Transforms/Instrumentation/ProfilingUtils.h @@ -1,10 +1,10 @@ //===- ProfilingUtils.h - Helper functions shared by profilers --*- C++ -*-===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This files defines a few helper functions which are used by profile diff --git a/lib/Transforms/Instrumentation/TraceBasicBlocks.cpp b/lib/Transforms/Instrumentation/TraceBasicBlocks.cpp index 68d50ae..ae8a8bd 100644 --- a/lib/Transforms/Instrumentation/TraceBasicBlocks.cpp +++ b/lib/Transforms/Instrumentation/TraceBasicBlocks.cpp @@ -1,10 +1,10 @@ //===- TraceBasicBlocks.cpp - Insert basic-block trace instrumentation ----===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This pass instruments the specified program with calls into a runtime diff --git a/lib/Transforms/Instrumentation/TraceValues.cpp b/lib/Transforms/Instrumentation/TraceValues.cpp index 5be8637..586c923 100644 --- a/lib/Transforms/Instrumentation/TraceValues.cpp +++ b/lib/Transforms/Instrumentation/TraceValues.cpp @@ -1,10 +1,10 @@ //===- TraceValues.cpp - Value Tracing for debugging ----------------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // Support for inserting LLVM code to print values at basic block and function @@ -41,7 +41,7 @@ static void TraceValuesAtBBExit(BasicBlock *BB, // We trace a particular function if no functions to trace were specified // or if the function is in the specified list. -// +// inline static bool TraceThisFunction(Function &F) { @@ -58,19 +58,19 @@ namespace { Function *RecordPtrFunc, *PushOnEntryFunc, *ReleaseOnReturnFunc; void doInitialization(Module &M); // Add prototypes for external functions }; - + class InsertTraceCode : public FunctionPass { protected: ExternalFuncs externalFuncs; public: - + // Add a prototype for runtime functions not already in the program. // bool doInitialization(Module &M); - + //-------------------------------------------------------------------------- // Function InsertCodeToTraceValues - // + // // Inserts tracing code for all live values at basic block and/or function // exits as specified by `traceBasicBlockExits' and `traceFunctionExits'. // @@ -131,13 +131,13 @@ void ExternalFuncs::doInitialization(Module &M) { // uint (sbyte*) HashPtrFunc = M.getOrInsertFunction("HashPointerToSeqNum", Type::UIntTy, SBP, 0); - + // void (sbyte*) - ReleasePtrFunc = M.getOrInsertFunction("ReleasePointerSeqNum", + ReleasePtrFunc = M.getOrInsertFunction("ReleasePointerSeqNum", Type::VoidTy, SBP, 0); RecordPtrFunc = M.getOrInsertFunction("RecordPointer", Type::VoidTy, SBP, 0); - + PushOnEntryFunc = M.getOrInsertFunction("PushPointerSet", Type::VoidTy, 0); ReleaseOnReturnFunc = M.getOrInsertFunction("ReleasePointersPopSet", Type::VoidTy, 0); @@ -158,7 +158,7 @@ static inline GlobalVariable *getStringRef(Module *M, const std::string &str) { // Create the global variable and record it in the module // The GV will be renamed to a unique name if needed. - GlobalVariable *GV = new GlobalVariable(Init->getType(), true, + GlobalVariable *GV = new GlobalVariable(Init->getType(), true, GlobalValue::InternalLinkage, Init, "trstr"); M->getGlobalList().push_back(GV); @@ -166,12 +166,12 @@ static inline GlobalVariable *getStringRef(Module *M, const std::string &str) { } -// +// // Check if this instruction has any uses outside its basic block, // or if it used by either a Call or Return instruction (ditto). // (Values stored to memory within this BB are live at end of BB but are // traced at the store instruction, not where they are computed.) -// +// static inline bool LiveAtBBExit(const Instruction* I) { const BasicBlock *BB = I->getParent(); for (Value::use_const_iterator U = I->use_begin(); U != I->use_end(); ++U) @@ -186,7 +186,7 @@ static inline bool LiveAtBBExit(const Instruction* I) { static inline bool TraceThisOpCode(unsigned opCode) { // Explicitly test for opCodes *not* to trace so that any new opcodes will // be traced by default (VoidTy's are already excluded) - // + // return (opCode < Instruction::OtherOpsBegin && opCode != Instruction::Alloca && opCode != Instruction::PHI && @@ -198,7 +198,7 @@ static inline bool TraceThisOpCode(unsigned opCode) { // by a real computation, not just a copy (see TraceThisOpCode), and // -- it is a load instruction: we want to check values read from memory // -- or it is live at exit from the basic block (i.e., ignore local temps) -// +// static bool ShouldTraceValue(const Instruction *I) { return I->getType() != Type::VoidTy && @@ -216,7 +216,7 @@ static std::string getPrintfCodeFor(const Value *V) { return DisablePtrHashing ? "0x%p" : "%d"; else if (V->getType()->isIntegral()) return "%d"; - + assert(0 && "Illegal value to print out..."); return ""; } @@ -245,7 +245,7 @@ static void InsertPrintInst(Value *V, BasicBlock *BB, Instruction *InsertBefore, // Turn the format string into an sbyte * Constant *GEP=ConstantExpr::getGetElementPtr(fmtVal, std::vector<Constant*>(2,Constant::getNullValue(Type::LongTy))); - + // Insert a call to the hash function if this is a pointer value if (V && isa<PointerType>(V->getType()) && !DisablePtrHashing) { const Type *SBP = PointerType::get(Type::SByteTy); @@ -255,14 +255,14 @@ static void InsertPrintInst(Value *V, BasicBlock *BB, Instruction *InsertBefore, std::vector<Value*> HashArgs(1, V); V = new CallInst(HashPtrToSeqNum, HashArgs, "ptrSeqNum", InsertBefore); } - + // Insert the first print instruction to print the string flag: std::vector<Value*> PrintArgs; PrintArgs.push_back(GEP); if (V) PrintArgs.push_back(V); new CallInst(Printf, PrintArgs, "trace", InsertBefore); } - + static void InsertVerbosePrintInst(Value *V, BasicBlock *BB, Instruction *InsertBefore, @@ -274,11 +274,11 @@ static void InsertVerbosePrintInst(Value *V, BasicBlock *BB, Printf, HashPtrToSeqNum); } -static void +static void InsertReleaseInst(Value *V, BasicBlock *BB, Instruction *InsertBefore, Function* ReleasePtrFunc) { - + const Type *SBP = PointerType::get(Type::SByteTy); if (V->getType() != SBP) // Cast pointer to be sbyte* V = new CastInst(V, SBP, "RPSN_cast", InsertBefore); @@ -287,7 +287,7 @@ InsertReleaseInst(Value *V, BasicBlock *BB, new CallInst(ReleasePtrFunc, releaseArgs, "", InsertBefore); } -static void +static void InsertRecordInst(Value *V, BasicBlock *BB, Instruction *InsertBefore, Function* RecordPtrFunc) { @@ -302,17 +302,17 @@ InsertRecordInst(Value *V, BasicBlock *BB, // Look for alloca and free instructions. These are the ptrs to release. // Release the free'd pointers immediately. Record the alloca'd pointers // to be released on return from the current function. -// +// static void ReleasePtrSeqNumbers(BasicBlock *BB, ExternalFuncs& externalFuncs) { - + for (BasicBlock::iterator II=BB->begin(), IE = BB->end(); II != IE; ++II) if (FreeInst *FI = dyn_cast<FreeInst>(II)) InsertReleaseInst(FI->getOperand(0), BB, FI,externalFuncs.ReleasePtrFunc); else if (AllocaInst *AI = dyn_cast<AllocaInst>(II)) InsertRecordInst(AI, BB, AI->getNext(), externalFuncs.RecordPtrFunc); -} +} // Insert print instructions at the end of basic block BB for each value @@ -323,15 +323,15 @@ ReleasePtrSeqNumbers(BasicBlock *BB, // for printing at the exit from the function. (Note that in each invocation // of the function, this will only get the last value stored for each static // store instruction). -// +// static void TraceValuesAtBBExit(BasicBlock *BB, Function *Printf, Function* HashPtrToSeqNum, std::vector<Instruction*> *valuesStoredInFunction) { // Get an iterator to point to the insertion location, which is // just before the terminator instruction. - // + // TerminatorInst *InsertPos = BB->getTerminator(); - + std::ostringstream OutStr; WriteAsOperand(OutStr, BB, false); InsertPrintInst(0, BB, InsertPos, "LEAVING BB:" + OutStr.str(), @@ -340,7 +340,7 @@ static void TraceValuesAtBBExit(BasicBlock *BB, // Insert a print instruction for each instruction preceding InsertPos. // The print instructions must go before InsertPos, so we use the // instruction *preceding* InsertPos to check when to terminate the loop. - // + // for (BasicBlock::iterator II = BB->begin(); &*II != InsertPos; ++II) { if (StoreInst *SI = dyn_cast<StoreInst>(II)) { // Trace the stored value and address @@ -380,12 +380,12 @@ static inline void InsertCodeToShowFunctionExit(BasicBlock *BB, Function* HashPtrToSeqNum) { // Get an iterator to point to the insertion location ReturnInst *Ret = cast<ReturnInst>(BB->getTerminator()); - + std::ostringstream OutStr; WriteAsOperand(OutStr, BB->getParent(), true); InsertPrintInst(0, BB, Ret, "LEAVING FUNCTION: " + OutStr.str(), Printf, HashPtrToSeqNum); - + // print the return value, if any if (BB->getParent()->getReturnType() != Type::VoidTy) InsertPrintInst(Ret->getReturnValue(), BB, Ret, " Returning: ", @@ -396,14 +396,14 @@ static inline void InsertCodeToShowFunctionExit(BasicBlock *BB, bool InsertTraceCode::runOnFunction(Function &F) { if (!TraceThisFunction(F)) return false; - + std::vector<Instruction*> valuesStoredInFunction; std::vector<BasicBlock*> exitBlocks; // Insert code to trace values at function entry InsertCodeToShowFunctionEntry(F, externalFuncs.PrintfFunc, externalFuncs.HashPtrFunc); - + // Push a pointer set for recording alloca'd pointers at entry. if (!DisablePtrHashing) new CallInst(externalFuncs.PushOnEntryFunc, std::vector<Value*>(), "", @@ -419,18 +419,18 @@ bool InsertTraceCode::runOnFunction(Function &F) { if (!DisablePtrHashing) // release seq. numbers on free/ret ReleasePtrSeqNumbers(BB, externalFuncs); } - + for (unsigned i=0; i != exitBlocks.size(); ++i) { // Insert code to trace values at function exit InsertCodeToShowFunctionExit(exitBlocks[i], externalFuncs.PrintfFunc, externalFuncs.HashPtrFunc); - + // Release all recorded pointers before RETURN. Do this LAST! if (!DisablePtrHashing) new CallInst(externalFuncs.ReleaseOnReturnFunc, std::vector<Value*>(), "", exitBlocks[i]->getTerminator()); } - + return true; } diff --git a/lib/Transforms/LevelRaise.cpp b/lib/Transforms/LevelRaise.cpp index a3b8a9b..c15aa25 100644 --- a/lib/Transforms/LevelRaise.cpp +++ b/lib/Transforms/LevelRaise.cpp @@ -1,10 +1,10 @@ //===- LevelRaise.cpp - Code to change LLVM to higher level ---------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements the 'raising' part of the LevelChange API. This is @@ -37,7 +37,7 @@ StartInst("raise-start-inst", cl::Hidden, cl::value_desc("inst name"), static Statistic<> NumLoadStorePeepholes("raise", "Number of load/store peepholes"); -static Statistic<> +static Statistic<> NumGEPInstFormed("raise", "Number of other getelementptr's formed"); static Statistic<> @@ -138,14 +138,14 @@ static bool HandleCastToPointer(BasicBlock::iterator BI, PRINT_PEEPHOLE2("cast-add-to-gep:in", *Src, CI); - // If we have a getelementptr capability... transform all of the + // If we have a getelementptr capability... transform all of the // add instruction uses into getelementptr's. while (!CI.use_empty()) { BinaryOperator *I = cast<BinaryOperator>(*CI.use_begin()); assert((I->getOpcode() == Instruction::Add || - I->getOpcode() == Instruction::Sub) && + I->getOpcode() == Instruction::Sub) && "Use is not a valid add instruction!"); - + // Get the value added to the cast result pointer... Value *OtherPtr = I->getOperand((I->getOperand(0) == &CI) ? 1 : 0); @@ -156,7 +156,7 @@ static bool HandleCastToPointer(BasicBlock::iterator BI, // one index (from code above), so we just need to negate the pointer index // long value. if (I->getOpcode() == Instruction::Sub) { - Instruction *Neg = BinaryOperator::createNeg(GEP->getOperand(1), + Instruction *Neg = BinaryOperator::createNeg(GEP->getOperand(1), GEP->getOperand(1)->getName()+".neg", I); GEP->setOperand(1, Neg); } @@ -276,7 +276,7 @@ bool RPR::PeepholeOptimize(BasicBlock *BB, BasicBlock::iterator &BI) { ConvertedTypes[CI] = CI->getType(); // Make sure the cast doesn't change if (ExpressionConvertibleToType(Src, DestTy, ConvertedTypes, TD)) { PRINT_PEEPHOLE3("CAST-SRC-EXPR-CONV:in ", *Src, *CI, *BB->getParent()); - + DEBUG(std::cerr << "\nCONVERTING SRC EXPR TYPE:\n"); { // ValueMap must be destroyed before function verified! ValueMapCache ValueMap; @@ -284,7 +284,7 @@ bool RPR::PeepholeOptimize(BasicBlock *BB, BasicBlock::iterator &BI) { if (Constant *CPV = dyn_cast<Constant>(E)) CI->replaceAllUsesWith(CPV); - + PRINT_PEEPHOLE1("CAST-SRC-EXPR-CONV:out", *E); DEBUG(std::cerr << "DONE CONVERTING SRC EXPR TYPE: \n" << *BB->getParent()); @@ -376,7 +376,7 @@ bool RPR::PeepholeOptimize(BasicBlock *BB, BasicBlock::iterator &BI) { if (const StructType *CurSTy = dyn_cast<StructType>(CurCTy)) { // Check for a zero element struct type... if we have one, bail. if (CurSTy->getNumElements() == 0) break; - + // Grab the first element of the struct type, which must lie at // offset zero in the struct. // @@ -390,13 +390,13 @@ bool RPR::PeepholeOptimize(BasicBlock *BB, BasicBlock::iterator &BI) { // Did we find what we're looking for? if (ElTy->isLosslesslyConvertibleTo(DestPointedTy)) break; - + // Nope, go a level deeper. ++Depth; CurCTy = dyn_cast<CompositeType>(ElTy); ElTy = 0; } - + // Did we find what we were looking for? If so, do the transformation if (ElTy) { PRINT_PEEPHOLE1("cast-for-first:in", *CI); @@ -411,7 +411,7 @@ bool RPR::PeepholeOptimize(BasicBlock *BB, BasicBlock::iterator &BI) { // the old src value. // CI->setOperand(0, GEP); - + PRINT_PEEPHOLE2("cast-for-first:out", *GEP, *CI); ++NumGEPInstFormed; return true; @@ -422,12 +422,12 @@ bool RPR::PeepholeOptimize(BasicBlock *BB, BasicBlock::iterator &BI) { } else if (StoreInst *SI = dyn_cast<StoreInst>(I)) { Value *Val = SI->getOperand(0); Value *Pointer = SI->getPointerOperand(); - + // Peephole optimize the following instructions: // %t = cast <T1>* %P to <T2> * ;; If T1 is losslessly convertible to T2 // store <T2> %V, <T2>* %t // - // Into: + // Into: // %t = cast <T2> %V to <T1> // store <T1> %t2, <T1>* %P // @@ -460,12 +460,12 @@ bool RPR::PeepholeOptimize(BasicBlock *BB, BasicBlock::iterator &BI) { Value *Pointer = LI->getOperand(0); const Type *PtrElType = cast<PointerType>(Pointer->getType())->getElementType(); - + // Peephole optimize the following instructions: // %Val = cast <T1>* to <T2>* ;; If T1 is losslessly convertible to T2 // %t = load <T2>* %P // - // Into: + // Into: // %t = load <T1>* %P // %Val = cast <T1> to <T2> // @@ -483,7 +483,7 @@ bool RPR::PeepholeOptimize(BasicBlock *BB, BasicBlock::iterator &BI) { // Create the new load instruction... loading the pre-casted value LoadInst *NewLI = new LoadInst(CastSrc, LI->getName(), BI); - + // Insert the new T cast instruction... stealing old T's name CastInst *NCI = new CastInst(NewLI, LI->getType(), CI->getName()); @@ -540,7 +540,7 @@ bool RPR::PeepholeOptimize(BasicBlock *BB, BasicBlock::iterator &BI) { std::vector<Value*>(CI->op_begin()+1, CI->op_end())); ++BI; ReplaceInstWithInst(CI, NewCall); - + ++NumVarargCallChanges; return true; } @@ -559,7 +559,7 @@ bool RPR::DoRaisePass(Function &F) { for (BasicBlock::iterator BI = BB->begin(); BI != BB->end();) { DEBUG(std::cerr << "LevelRaising: " << *BI); if (dceInstruction(BI) || doConstantPropagation(BI)) { - Changed = true; + Changed = true; ++NumDCEorCP; DEBUG(std::cerr << "***\t\t^^-- Dead code eliminated!\n"); } else if (PeepholeOptimize(BB, BI)) { diff --git a/lib/Transforms/Scalar/ADCE.cpp b/lib/Transforms/Scalar/ADCE.cpp index 089124a..a2ca367 100644 --- a/lib/Transforms/Scalar/ADCE.cpp +++ b/lib/Transforms/Scalar/ADCE.cpp @@ -1,14 +1,14 @@ //===- ADCE.cpp - Code to perform aggressive dead code elimination --------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements "aggressive" dead code elimination. ADCE is DCe where -// values are assumed to be dead until proven otherwise. This is similar to +// values are assumed to be dead until proven otherwise. This is similar to // SCCP, except applied to the liveness of values. // //===----------------------------------------------------------------------===// @@ -116,11 +116,11 @@ void ADCE::markBlockAlive(BasicBlock *BB) { if (It != CDG.end()) { // Get the blocks that this node is control dependent on... const PostDominanceFrontier::DomSetType &CDB = It->second; - for (PostDominanceFrontier::DomSetType::const_iterator I = + for (PostDominanceFrontier::DomSetType::const_iterator I = CDB.begin(), E = CDB.end(); I != E; ++I) markTerminatorLive(*I); // Mark all their terminators as live } - + // If this basic block is live, and it ends in an unconditional branch, then // the branch is alive as well... if (BranchInst *BI = dyn_cast<BranchInst>(BB->getTerminator())) @@ -162,7 +162,7 @@ TerminatorInst *ADCE::convertToUnconditionalBranch(TerminatorInst *TI) { // Remove entries from PHI nodes to avoid confusing ourself later... for (unsigned i = 1, e = TI->getNumSuccessors(); i != e; ++i) TI->getSuccessor(i)->removePredecessor(BB); - + // Delete the old branch itself... BB->getInstList().erase(TI); return NB; @@ -203,7 +203,7 @@ bool ADCE::doADCE() { } // Iterate over all of the instructions in the function, eliminating trivially - // dead instructions, and marking instructions live that are known to be + // dead instructions, and marking instructions live that are known to be // needed. Perform the walk in depth first order so that we avoid marking any // instructions live in basic blocks that are unreachable. These blocks will // be eliminated later, along with the instructions inside. @@ -338,7 +338,7 @@ bool ADCE::doADCE() { return MadeChanges; } - + // If the entry node is dead, insert a new entry node to eliminate the entry // node as a special case. @@ -350,7 +350,7 @@ bool ADCE::doADCE() { AliveBlocks.insert(NewEntry); // This block is always alive! LiveSet.insert(NewEntry->getTerminator()); // The branch is live } - + // Loop over all of the alive blocks in the function. If any successor // blocks are not alive, we adjust the outgoing branches to branch to the // first live postdominator of the live block, adjusting any PHI nodes in @@ -360,7 +360,7 @@ bool ADCE::doADCE() { if (AliveBlocks.count(I)) { BasicBlock *BB = I; TerminatorInst *TI = BB->getTerminator(); - + // If the terminator instruction is alive, but the block it is contained // in IS alive, this means that this terminator is a conditional branch on // a condition that doesn't matter. Make it an unconditional branch to @@ -392,7 +392,7 @@ bool ADCE::doADCE() { break; } } - } + } // There is a special case here... if there IS no post-dominator for // the block we have nowhere to point our branch to. Instead, convert @@ -411,12 +411,12 @@ bool ADCE::doADCE() { // branch into an infinite loop into a return instruction! // RemoveSuccessor(TI, i); - + // RemoveSuccessor may replace TI... make sure we have a fresh // pointer. // TI = BB->getTerminator(); - + // Rescan this successor... --i; } else { @@ -443,7 +443,7 @@ bool ADCE::doADCE() { int OldIdx = PN->getBasicBlockIndex(LastDead); assert(OldIdx != -1 &&"LastDead is not a pred of NextAlive!"); Value *InVal = PN->getIncomingValue(OldIdx); - + // Add an incoming value for BB now... PN->addIncoming(InVal, BB); } diff --git a/lib/Transforms/Scalar/BasicBlockPlacement.cpp b/lib/Transforms/Scalar/BasicBlockPlacement.cpp index ec31bbf..c926c56 100644 --- a/lib/Transforms/Scalar/BasicBlockPlacement.cpp +++ b/lib/Transforms/Scalar/BasicBlockPlacement.cpp @@ -1,10 +1,10 @@ //===-- BasicBlockPlacement.cpp - Basic Block Code Layout optimization ----===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements a very simple profile guided basic block placement @@ -37,7 +37,7 @@ using namespace llvm; namespace { Statistic<> NumMoved("block-placement", "Number of basic blocks moved"); - + struct BlockPlacement : public FunctionPass { virtual bool runOnFunction(Function &F); @@ -78,11 +78,11 @@ bool BlockPlacement::runOnFunction(Function &F) { PI = &getAnalysis<ProfileInfo>(); NumMovedBlocks = 0; - InsertPos = F.begin(); + InsertPos = F.begin(); // Recursively place all blocks. PlaceBlocks(F.begin()); - + PlacedBlocks.clear(); NumMoved += NumMovedBlocks; return NumMovedBlocks != 0; @@ -115,12 +115,12 @@ void BlockPlacement::PlaceBlocks(BasicBlock *BB) { while (1) { // Okay, now place any unplaced successors. succ_iterator SI = succ_begin(BB), E = succ_end(BB); - + // Scan for the first unplaced successor. for (; SI != E && PlacedBlocks.count(*SI); ++SI) /*empty*/; if (SI == E) return; // No more successors to place. - + unsigned MaxExecutionCount = PI->getExecutionCount(*SI); BasicBlock *MaxSuccessor = *SI; diff --git a/lib/Transforms/Scalar/CondPropagate.cpp b/lib/Transforms/Scalar/CondPropagate.cpp index 0e63b51..d3ad577 100644 --- a/lib/Transforms/Scalar/CondPropagate.cpp +++ b/lib/Transforms/Scalar/CondPropagate.cpp @@ -1,10 +1,10 @@ //===-- CondPropagate.cpp - Propagate Conditional Expressions -------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This pass propagates information about conditional expressions through the @@ -73,7 +73,7 @@ void CondProp::SimplifyBlock(BasicBlock *BB) { if (BI->isConditional() && isa<PHINode>(BI->getCondition()) && cast<PHINode>(BI->getCondition())->getParent() == BB) SimplifyPredecessors(BI); - + } else if (SwitchInst *SI = dyn_cast<SwitchInst>(BB->getTerminator())) { if (isa<PHINode>(SI->getCondition()) && cast<PHINode>(SI->getCondition())->getParent() == BB) diff --git a/lib/Transforms/Scalar/ConstantProp.cpp b/lib/Transforms/Scalar/ConstantProp.cpp index a3fa4a9..8955aee 100644 --- a/lib/Transforms/Scalar/ConstantProp.cpp +++ b/lib/Transforms/Scalar/ConstantProp.cpp @@ -1,10 +1,10 @@ //===- ConstantProp.cpp - Code to perform Simple Constant Propagation -----===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements constant propagation and merging: @@ -66,7 +66,7 @@ bool ConstantPropagation::runOnFunction(Function &F) { for (Value::use_iterator UI = I->use_begin(), UE = I->use_end(); UI != UE; ++UI) WorkList.insert(cast<Instruction>(*UI)); - + // Replace all of the uses of a variable with uses of the constant. I->replaceAllUsesWith(C); diff --git a/lib/Transforms/Scalar/CorrelatedExprs.cpp b/lib/Transforms/Scalar/CorrelatedExprs.cpp index da8c500..f529502 100644 --- a/lib/Transforms/Scalar/CorrelatedExprs.cpp +++ b/lib/Transforms/Scalar/CorrelatedExprs.cpp @@ -1,10 +1,10 @@ //===- CorrelatedExprs.cpp - Pass to detect and eliminated c.e.'s ---------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // Correlated Expression Elimination propagates information from conditional @@ -178,7 +178,7 @@ namespace { // empty - return true if this region has no information known about it. bool empty() const { return ValueMap.empty(); } - + const RegionInfo &operator=(const RegionInfo &RI) { ValueMap = RI.ValueMap; return *this; @@ -204,7 +204,7 @@ namespace { if (I != ValueMap.end()) return &I->second; return 0; } - + /// removeValueInfo - Remove anything known about V from our records. This /// works whether or not we know anything about V. /// @@ -281,7 +281,7 @@ namespace { bool SimplifyBasicBlock(BasicBlock &BB, const RegionInfo &RI); bool SimplifyInstruction(Instruction *Inst, const RegionInfo &RI); - }; + }; RegisterOpt<CEE> X("cee", "Correlated Expression Elimination"); } @@ -299,7 +299,7 @@ bool CEE::runOnFunction(Function &F) { // blocks. DS = &getAnalysis<DominatorSet>(); DT = &getAnalysis<DominatorTree>(); - + std::set<BasicBlock*> VisitedBlocks; bool Changed = TransformRegion(&F.getEntryBlock(), VisitedBlocks); @@ -458,13 +458,13 @@ bool CEE::ForwardCorrelatedEdgeDestination(TerminatorInst *TI, unsigned SuccNo, for (BasicBlock::iterator I = OldSucc->begin(), E = OldSucc->end(); I!=E; ++I) if (I->getType() != Type::VoidTy) NewRI.removeValueInfo(I); - + // Put the newly discovered information into the RegionInfo... for (BasicBlock::iterator I = OldSucc->begin(), E = OldSucc->end(); I!=E; ++I) if (PHINode *PN = dyn_cast<PHINode>(I)) { int OpNum = PN->getBasicBlockIndex(BB); assert(OpNum != -1 && "PHI doesn't have incoming edge for predecessor!?"); - PropagateEquality(PN, PN->getIncomingValue(OpNum), NewRI); + PropagateEquality(PN, PN->getIncomingValue(OpNum), NewRI); } else if (SetCondInst *SCI = dyn_cast<SetCondInst>(I)) { Relation::KnownResult Res = getSetCCResult(SCI, NewRI); if (Res == Relation::Unknown) return false; @@ -472,7 +472,7 @@ bool CEE::ForwardCorrelatedEdgeDestination(TerminatorInst *TI, unsigned SuccNo, } else { assert(isa<BranchInst>(*I) && "Unexpected instruction type!"); } - + // Compute the facts implied by what we have discovered... ComputeReplacements(NewRI); @@ -486,7 +486,7 @@ bool CEE::ForwardCorrelatedEdgeDestination(TerminatorInst *TI, unsigned SuccNo, ForwardSuccessorTo(TI, SuccNo, BI->getSuccessor(!CB->getValue()), NewRI); return true; } - + return false; } @@ -582,7 +582,7 @@ void CEE::ForwardSuccessorTo(TerminatorInst *TI, unsigned SuccNo, // node yet though if this is the last edge into it. Value *EdgeValue = PN->removeIncomingValue(BB, false); - // Make sure that anything that used to use PN now refers to EdgeValue + // Make sure that anything that used to use PN now refers to EdgeValue ReplaceUsesOfValueInRegion(PN, EdgeValue, Dest); // If there is only one value left coming into the PHI node, replace the PHI @@ -603,7 +603,7 @@ void CEE::ForwardSuccessorTo(TerminatorInst *TI, unsigned SuccNo, ++I; // Otherwise, move on to the next PHI node } } - + // Actually revector the branch now... TI->setSuccessor(SuccNo, Dest); @@ -689,7 +689,7 @@ static void CalcRegionExitBlocks(BasicBlock *Header, BasicBlock *BB, } else { // Header does not dominate this block, but we have a predecessor that does // dominate us. Add ourself to the list. - RegionExitBlocks.push_back(BB); + RegionExitBlocks.push_back(BB); } } @@ -703,7 +703,7 @@ void CEE::CalculateRegionExitBlocks(BasicBlock *BB, BasicBlock *OldSucc, // Recursively calculate blocks we are interested in... CalcRegionExitBlocks(BB, BB, Visited, *DS, RegionExitBlocks); - + // Filter out blocks that are not dominated by OldSucc... for (unsigned i = 0; i != RegionExitBlocks.size(); ) { if (DS->dominates(OldSucc, RegionExitBlocks[i])) @@ -738,7 +738,7 @@ void CEE::InsertRegionExitMerges(PHINode *BBVal, Instruction *OldVal, // otherwise use OldVal. NewPN->addIncoming(DS->dominates(BB, *PI) ? BBVal : OldVal, *PI); } - + // Now make everyone dominated by this block use this new value! ReplaceUsesOfValueInRegion(OldVal, NewPN, FBlock); } @@ -783,7 +783,7 @@ void CEE::PropagateBranchInfo(BranchInst *BI) { // PropagateEquality(BI->getCondition(), ConstantBool::True, getRegionInfo(BI->getSuccessor(0))); - + // Propagate information into the false block... // PropagateEquality(BI->getCondition(), ConstantBool::False, @@ -825,7 +825,7 @@ void CEE::PropagateEquality(Value *Op0, Value *Op1, RegionInfo &RI) { PropagateEquality(Inst->getOperand(0), CB, RI); PropagateEquality(Inst->getOperand(1), CB, RI); } - + // If we know that this instruction is an OR instruction, and the result // is false, this means that both operands to the OR are know to be false // as well. @@ -834,7 +834,7 @@ void CEE::PropagateEquality(Value *Op0, Value *Op1, RegionInfo &RI) { PropagateEquality(Inst->getOperand(0), CB, RI); PropagateEquality(Inst->getOperand(1), CB, RI); } - + // If we know that this instruction is a NOT instruction, we know that the // operand is known to be the inverse of whatever the current value is. // @@ -857,7 +857,7 @@ void CEE::PropagateEquality(Value *Op0, Value *Op1, RegionInfo &RI) { } else { // If we know the condition is false... // We know the opposite of the condition is true... Instruction::BinaryOps C = SCI->getInverseCondition(); - + PropagateRelation(C, SCI->getOperand(0), SCI->getOperand(1), RI); PropagateRelation(SetCondInst::getSwappedCondition(C), SCI->getOperand(1), SCI->getOperand(0), RI); @@ -1065,7 +1065,7 @@ Relation::KnownResult CEE::getSetCCResult(SetCondInst *SCI, const RegionInfo &RI) { Value *Op0 = SCI->getOperand(0), *Op1 = SCI->getOperand(1); Instruction::BinaryOps Opcode = SCI->getOpcode(); - + if (isa<Constant>(Op0)) { if (isa<Constant>(Op1)) { if (Constant *Result = ConstantFoldInstruction(SCI)) { @@ -1098,7 +1098,7 @@ Relation::KnownResult CEE::getSetCCResult(SetCondInst *SCI, // If the intersection of the two ranges is empty, then the condition // could never be true! - // + // if (Int.isEmptySet()) { Result = Relation::KnownFalse; @@ -1254,7 +1254,7 @@ Relation::getImpliedResult(Instruction::BinaryOps Op) const { // print - Implement the standard print form to print out analysis information. void CEE::print(std::ostream &O, const Module *M) const { O << "\nPrinting Correlated Expression Info:\n"; - for (std::map<BasicBlock*, RegionInfo>::const_iterator I = + for (std::map<BasicBlock*, RegionInfo>::const_iterator I = RegionInfoMap.begin(), E = RegionInfoMap.end(); I != E; ++I) I->second.print(O); } diff --git a/lib/Transforms/Scalar/DCE.cpp b/lib/Transforms/Scalar/DCE.cpp index ae61208..759180a 100644 --- a/lib/Transforms/Scalar/DCE.cpp +++ b/lib/Transforms/Scalar/DCE.cpp @@ -1,10 +1,10 @@ //===- DCE.cpp - Code to perform dead code elimination --------------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements dead inst elimination and dead code elimination. @@ -49,7 +49,7 @@ namespace { AU.setPreservesCFG(); } }; - + RegisterOpt<DeadInstElimination> X("die", "Dead Instruction Elimination"); } @@ -81,7 +81,7 @@ bool DCE::runOnFunction(Function &F) { WorkList.push_back(&*i); } std::set<Instruction*> DeadInsts; - + // Loop over the worklist finding instructions that are dead. If they are // dead make them drop all of their uses, making other instructions // potentially dead, and work until the worklist is empty. @@ -89,7 +89,7 @@ bool DCE::runOnFunction(Function &F) { while (!WorkList.empty()) { Instruction *I = WorkList.back(); WorkList.pop_back(); - + if (isInstructionTriviallyDead(I)) { // If the instruction is dead... // Loop over all of the values that the instruction uses, if there are // instructions being used, add them to the worklist, because they might diff --git a/lib/Transforms/Scalar/DeadStoreElimination.cpp b/lib/Transforms/Scalar/DeadStoreElimination.cpp index a823e14..07d5c65 100644 --- a/lib/Transforms/Scalar/DeadStoreElimination.cpp +++ b/lib/Transforms/Scalar/DeadStoreElimination.cpp @@ -1,10 +1,10 @@ //===- DeadStoreElimination.cpp - Dead Store Elimination ------------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements a trivial dead store elimination that only considers @@ -39,9 +39,9 @@ namespace { Changed |= runOnBasicBlock(*I); return Changed; } - + bool runOnBasicBlock(BasicBlock &BB); - + void DeleteDeadInstructionChains(Instruction *I, SetVector<Instruction*> &DeadInsts); @@ -87,7 +87,7 @@ bool DSE::runOnBasicBlock(BasicBlock &BB) { bool MadeChange = false; for (BasicBlock::iterator BBI = BB.end(); BBI != BB.begin(); ) { Instruction *I = --BBI; // Keep moving iterator backwards - + // If this is a free instruction, it makes the free'd location dead! if (FreeInst *FI = dyn_cast<FreeInst>(I)) { // Free instructions make any stores to the free'd location dead. @@ -161,7 +161,7 @@ void DSE::DeleteDeadInstructionChains(Instruction *I, DeadInsts.insert(Op); // Attempt to nuke it later. I->setOperand(i, 0); // Drop from the operand list. } - + I->eraseFromParent(); ++NumOther; } diff --git a/lib/Transforms/Scalar/GCSE.cpp b/lib/Transforms/Scalar/GCSE.cpp index dbabe26..a785685 100644 --- a/lib/Transforms/Scalar/GCSE.cpp +++ b/lib/Transforms/Scalar/GCSE.cpp @@ -1,10 +1,10 @@ //===-- GCSE.cpp - SSA-based Global Common Subexpression Elimination ------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This pass is designed to be a very quick global transformation that @@ -116,7 +116,7 @@ bool GCSE::runOnFunction(Function &F) { else { I = Inst; --I; } - + // First check to see if we were able to value number this instruction // to a non-instruction value. If so, prefer that value over other // instructions which may compute the same thing. @@ -186,14 +186,14 @@ void GCSE::ReplaceInstructionWith(Instruction *I, Value *V) { getAnalysis<ValueNumbering>().deleteValue(I); I->replaceAllUsesWith(V); - + if (InvokeInst *II = dyn_cast<InvokeInst>(I)) { // Removing an invoke instruction requires adding a branch to the normal // destination and removing PHI node entries in the exception destination. new BranchInst(II->getNormalDest(), II); II->getUnwindDest()->removePredecessor(II->getParent()); } - + // Erase the instruction from the program. I->getParent()->getInstList().erase(I); } diff --git a/lib/Transforms/Scalar/IndVarSimplify.cpp b/lib/Transforms/Scalar/IndVarSimplify.cpp index aabc96c..88ad6d2 100644 --- a/lib/Transforms/Scalar/IndVarSimplify.cpp +++ b/lib/Transforms/Scalar/IndVarSimplify.cpp @@ -1,10 +1,10 @@ //===- IndVarSimplify.cpp - Induction Variable Elimination ----------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This transformation analyzes and transforms the induction variables (and @@ -76,7 +76,7 @@ namespace { bool isInsertedInstruction(Instruction *I) const { return InsertedInstructions.count(I); } - + /// getOrInsertCanonicalInductionVariable - This method returns the /// canonical induction variable of the specified type for the specified /// loop (inserting one if there is none). A canonical induction variable @@ -128,7 +128,7 @@ namespace { return ConstantExpr::getCast(C, Ty); else if (Instruction *I = dyn_cast<Instruction>(V)) { // Check to see if there is already a cast. If there is, use it. - for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); + for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); UI != E; ++UI) { if ((*UI)->getType() == Ty) if (CastInst *CI = dyn_cast<CastInst>(cast<Instruction>(*UI))) { @@ -206,10 +206,10 @@ Value *SCEVExpander::visitMulExpr(SCEVMulExpr *S) { if (SCEVConstant *SC = dyn_cast<SCEVConstant>(S->getOperand(0))) if (SC->getValue()->isAllOnesValue()) FirstOp = 1; - + int i = S->getNumOperands()-2; Value *V = expandInTy(S->getOperand(i+1), Ty); - + // Emit a bunch of multiply instructions for (; i >= FirstOp; --i) V = BinaryOperator::createMul(V, expandInTy(S->getOperand(i), Ty), @@ -358,7 +358,7 @@ DeleteTriviallyDeadInstructions(std::set<Instruction*> &Insts) { /// EliminatePointerRecurrence - Check to see if this is a trivial GEP pointer /// recurrence. If so, change it into an integer recurrence, permitting /// analysis by the SCEV routines. -void IndVarSimplify::EliminatePointerRecurrence(PHINode *PN, +void IndVarSimplify::EliminatePointerRecurrence(PHINode *PN, BasicBlock *Preheader, std::set<Instruction*> &DeadInsts) { assert(PN->getNumIncomingValues() == 2 && "Noncanonicalized loop!"); @@ -368,7 +368,7 @@ void IndVarSimplify::EliminatePointerRecurrence(PHINode *PN, dyn_cast<GetElementPtrInst>(PN->getIncomingValue(BackedgeIdx))) if (GEPI->getOperand(0) == PN) { assert(GEPI->getNumOperands() == 2 && "GEP types must mismatch!"); - + // Okay, we found a pointer recurrence. Transform this pointer // recurrence into an integer recurrence. Compute the value that gets // added to the pointer at every iteration. @@ -383,10 +383,10 @@ void IndVarSimplify::EliminatePointerRecurrence(PHINode *PN, Value *NewAdd = BinaryOperator::createAdd(NewPhi, AddedVal, GEPI->getName()+".rec", GEPI); NewPhi->addIncoming(NewAdd, PN->getIncomingBlock(BackedgeIdx)); - + // Update the existing GEP to use the recurrence. GEPI->setOperand(0, PN->getIncomingValue(PreheaderIdx)); - + // Update the GEP to use the new recurrence we just inserted. GEPI->setOperand(1, NewAdd); @@ -547,7 +547,7 @@ void IndVarSimplify::RewriteLoopExitValues(Loop *L) { bool HasConstantItCount = isa<SCEVConstant>(SE->getIterationCount(L)); std::set<Instruction*> InstructionsToDelete; - + for (unsigned i = 0, e = L->getBlocks().size(); i != e; ++i) if (LI->getLoopFor(L->getBlocks()[i]) == L) { // Not in a subloop... BasicBlock *BB = L->getBlocks()[i]; @@ -599,7 +599,7 @@ void IndVarSimplify::runOnLoop(Loop *L) { // BasicBlock *Header = L->getHeader(); BasicBlock *Preheader = L->getLoopPreheader(); - + std::set<Instruction*> DeadInsts; for (BasicBlock::iterator I = Header->begin(); isa<PHINode>(I); ++I) { PHINode *PN = cast<PHINode>(I); @@ -748,7 +748,7 @@ void IndVarSimplify::runOnLoop(Loop *L) { DeadInsts.insert(I); ++NumRemoved; Changed = true; - } + } } } #endif diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp index fcdd73d..5a2e4ef 100644 --- a/lib/Transforms/Scalar/InstructionCombining.cpp +++ b/lib/Transforms/Scalar/InstructionCombining.cpp @@ -1,10 +1,10 @@ //===- InstructionCombining.cpp - Combine multiple instructions -----------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // InstructionCombining - Combine instructions to form fewer, simple @@ -103,7 +103,7 @@ namespace { // null - No change was made // I - Change was made, I is still valid, I may be dead though // otherwise - Change was made, replace I with returned instruction - // + // Instruction *visitAdd(BinaryOperator &I); Instruction *visitSub(BinaryOperator &I); Instruction *visitMul(BinaryOperator &I); @@ -159,7 +159,7 @@ namespace { /// cast. Value *InsertCastBefore(Value *V, const Type *Ty, Instruction &Pos) { if (V->getType() == Ty) return V; - + Instruction *C = new CastInst(V, Ty, V->getName(), &Pos); WorkList.push_back(C); return C; @@ -275,7 +275,7 @@ bool InstCombiner::SimplifyCommutative(BinaryOperator &I) { bool Changed = false; if (getComplexity(I.getOperand(0)) < getComplexity(I.getOperand(1))) Changed = !I.swapOperands(); - + if (!I.isAssociative()) return Changed; Instruction::BinaryOps Opcode = I.getOpcode(); if (BinaryOperator *Op = dyn_cast<BinaryOperator>(I.getOperand(0))) @@ -302,7 +302,7 @@ bool InstCombiner::SimplifyCommutative(BinaryOperator &I) { I.setOperand(0, New); I.setOperand(1, Folded); return true; - } + } } return Changed; } @@ -427,7 +427,7 @@ Instruction *AssociativeOpt(BinaryOperator &Root, const Functor &F) { // reassociate the expression from ((? op A) op B) to (? op (A op B)) if (ShouldApply) { BasicBlock *BB = Root.getParent(); - + // Now all of the instructions are in the current basic block, go ahead // and perform the reassociation. Instruction *TmpLHSI = cast<Instruction>(Root.getOperand(0)); @@ -463,12 +463,12 @@ Instruction *AssociativeOpt(BinaryOperator &Root, const Functor &F) { TmpLHSI = NextLHSI; ExtraOperand = NextOp; } - + // Now that the instructions are reassociated, have the functor perform // the transformation... return F.apply(Root); } - + LHSI = dyn_cast<Instruction>(LHSI->getOperand(0)); } return 0; @@ -493,7 +493,7 @@ struct AddMaskingAnd { AddMaskingAnd(Constant *c) : C2(c) {} bool shouldApply(Value *LHS) const { ConstantInt *C1; - return match(LHS, m_And(m_Value(), m_ConstantInt(C1))) && + return match(LHS, m_And(m_Value(), m_ConstantInt(C1))) && ConstantExpr::getAnd(C1, C2)->isNullValue(); } Instruction *apply(BinaryOperator &Add) const { @@ -506,7 +506,7 @@ static Value *FoldOperationIntoSelectOperand(Instruction &I, Value *SO, if (isa<CastInst>(I)) { if (Constant *SOC = dyn_cast<Constant>(SO)) return ConstantExpr::getCast(SOC, I.getType()); - + return IC->InsertNewInstBefore(new CastInst(SO, I.getType(), SO->getName() + ".cast"), I); } @@ -615,7 +615,7 @@ Instruction *InstCombiner::visitAdd(BinaryOperator &I) { if (!I.getType()->isFloatingPoint() && // -0 + +0 = +0, so it's not a noop RHSC->isNullValue()) return ReplaceInstUsesWith(I, LHS); - + // X + (signbit) --> X ^ signbit if (ConstantInt *CI = dyn_cast<ConstantInt>(RHSC)) { unsigned NumBits = CI->getType()->getPrimitiveSize()*8; @@ -654,7 +654,7 @@ Instruction *InstCombiner::visitAdd(BinaryOperator &I) { if (Value *V = dyn_castNegVal(RHS)) return BinaryOperator::createSub(LHS, V); - + ConstantInt *C2; if (Value *X = dyn_castFoldableMul(LHS, C2)) { if (X == RHS) // X*C + X --> X * (C+1) @@ -696,7 +696,7 @@ Instruction *InstCombiner::visitAdd(BinaryOperator &I) { // See if the and mask includes all of these bits. uint64_t AddRHSHighBitsAnd = AddRHSHighBits & C2->getRawValue(); - + if (AddRHSHighBits == AddRHSHighBitsAnd) { // Okay, the xform is safe. Insert the new add pronto. Value *NewAdd = InsertNewInstBefore(BinaryOperator::createAdd(X, CRHS, @@ -832,7 +832,7 @@ Instruction *InstCombiner::visitSub(BinaryOperator &I) { Value *IIOp0 = Op1I->getOperand(0), *IIOp1 = Op1I->getOperand(1); Op1I->setOperand(0, IIOp1); Op1I->setOperand(1, IIOp0); - + // Create the new top level add instruction... return BinaryOperator::createAdd(Op0, Op1); } @@ -853,13 +853,13 @@ Instruction *InstCombiner::visitSub(BinaryOperator &I) { if (ConstantSInt *CSI = dyn_cast<ConstantSInt>(Op0)) if (CSI->isNullValue()) if (Constant *DivRHS = dyn_cast<Constant>(Op1I->getOperand(1))) - return BinaryOperator::createDiv(Op1I->getOperand(0), + return BinaryOperator::createDiv(Op1I->getOperand(0), ConstantExpr::getNeg(DivRHS)); // X - X*C --> X * (1-C) ConstantInt *C2; if (dyn_castFoldableMul(Op1I, C2) == Op0) { - Constant *CP1 = + Constant *CP1 = ConstantExpr::getSub(ConstantInt::get(I.getType(), 1), C2); return BinaryOperator::createMul(Op0, CP1); } @@ -877,7 +877,7 @@ Instruction *InstCombiner::visitSub(BinaryOperator &I) { if (Op0I->getOperand(0) == Op1) // (X-Y)-X == -Y return BinaryOperator::createNeg(Op0I->getOperand(1), I.getName()); } - + ConstantInt *C1; if (Value *X = dyn_castFoldableMul(Op0, C1)) { if (X == Op1) { // X*C - X --> X * (C-1) @@ -929,7 +929,7 @@ Instruction *InstCombiner::visitMul(BinaryOperator &I) { if (Constant *ShOp = dyn_cast<Constant>(SI->getOperand(1))) return BinaryOperator::createMul(SI->getOperand(0), ConstantExpr::getShl(CI, ShOp)); - + if (CI->isNullValue()) return ReplaceInstUsesWith(I, Op1); // X * 0 == 0 if (CI->equalsInt(1)) // X * 1 == X @@ -1004,7 +1004,7 @@ Instruction *InstCombiner::visitMul(BinaryOperator &I) { // or truncate to the multiply type. if (I.getType() != V->getType()) V = InsertNewInstBefore(new CastInst(V, I.getType(), V->getName()),I); - + Value *OtherOp = Op0 == BoolCast ? I.getOperand(1) : Op0; return BinaryOperator::createAnd(V, OtherOp); } @@ -1069,10 +1069,10 @@ Instruction *InstCombiner::visitDiv(BinaryOperator &I) { if (ConstantUInt *SFO = dyn_cast<ConstantUInt>(SI->getOperand(2))) { if (STO->getValue() == 0) { // Couldn't be this argument. I.setOperand(1, SFO); - return &I; + return &I; } else if (SFO->getValue() == 0) { I.setOperand(2, STO); - return &I; + return &I; } uint64_t TVA = STO->getValue(), FVA = SFO->getValue(); @@ -1083,7 +1083,7 @@ Instruction *InstCombiner::visitDiv(BinaryOperator &I) { 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"); @@ -1091,7 +1091,7 @@ Instruction *InstCombiner::visitDiv(BinaryOperator &I) { return new SelectInst(SI->getOperand(0), TSI, FSI); } } - + // 0 / X == 0, we don't need to preserve faults! if (ConstantInt *LHS = dyn_cast<ConstantInt>(Op0)) if (LHS->equalsInt(0)) @@ -1147,10 +1147,10 @@ Instruction *InstCombiner::visitRem(BinaryOperator &I) { if (ConstantUInt *SFO = dyn_cast<ConstantUInt>(SI->getOperand(2))) { if (STO->getValue() == 0) { // Couldn't be this argument. I.setOperand(1, SFO); - return &I; + return &I; } else if (SFO->getValue() == 0) { I.setOperand(1, STO); - return &I; + return &I; } if (!(STO->getValue() & (STO->getValue()-1)) && @@ -1162,7 +1162,7 @@ Instruction *InstCombiner::visitRem(BinaryOperator &I) { return new SelectInst(SI->getOperand(0), TrueAnd, FalseAnd); } } - + // 0 % X == 0, we don't need to preserve faults! if (ConstantInt *LHS = dyn_cast<ConstantInt>(Op0)) if (LHS->equalsInt(0)) @@ -1182,7 +1182,7 @@ static bool isMaxValueMinusOne(const ConstantInt *C) { } const ConstantSInt *CS = cast<ConstantSInt>(C); - + // Calculate 0111111111..11111 unsigned TypeBits = C->getType()->getPrimitiveSize()*8; int64_t Val = INT64_MAX; // All ones @@ -1196,8 +1196,8 @@ static bool isMinValuePlusOne(const ConstantInt *C) { return CU->getValue() == 1; const ConstantSInt *CS = cast<ConstantSInt>(C); - - // Calculate 1111111111000000000000 + + // Calculate 1111111111000000000000 unsigned TypeBits = C->getType()->getPrimitiveSize()*8; int64_t Val = -1; // All ones Val <<= TypeBits-1; // Shift over to the right spot @@ -1325,7 +1325,7 @@ static bool MaskedValueIsZero(Value *V, ConstantIntegral *Mask) { return true; if (ConstantIntegral *CI = dyn_cast<ConstantIntegral>(V)) return ConstantExpr::getAnd(CI, Mask)->isNullValue(); - + if (Instruction *I = dyn_cast<Instruction>(V)) { switch (I->getOpcode()) { case Instruction::And: @@ -1336,11 +1336,11 @@ static bool MaskedValueIsZero(Value *V, ConstantIntegral *Mask) { break; case Instruction::Or: // If the LHS and the RHS are MaskedValueIsZero, the result is also zero. - return MaskedValueIsZero(I->getOperand(1), Mask) && + return MaskedValueIsZero(I->getOperand(1), Mask) && MaskedValueIsZero(I->getOperand(0), Mask); case Instruction::Select: // If the T and F values are MaskedValueIsZero, the result is also zero. - return MaskedValueIsZero(I->getOperand(2), Mask) && + return MaskedValueIsZero(I->getOperand(2), Mask) && MaskedValueIsZero(I->getOperand(1), Mask); case Instruction::Cast: { const Type *SrcTy = I->getOperand(0)->getType(); @@ -1414,7 +1414,7 @@ Instruction *InstCombiner::OptAndOp(Instruction *Op, case Instruction::Or: if (Together == AndRHS) // (X | C) & C --> C return ReplaceInstUsesWith(TheAnd, AndRHS); - + if (Op->hasOneUse() && Together != OpRHS) { // (X | C1) & C2 --> (X | (C1&C2)) & C2 std::string Op0Name = Op->getName(); Op->setName(""); @@ -1439,7 +1439,7 @@ Instruction *InstCombiner::OptAndOp(Instruction *Op, // 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(); - + // Check to see if any bits below the one bit set in AndRHSV are set. if ((AddRHS & (AndRHSV-1)) == 0) { // If not, the only thing that can effect the output of the AND is @@ -1468,7 +1468,7 @@ Instruction *InstCombiner::OptAndOp(Instruction *Op, Constant *AllOne = ConstantIntegral::getAllOnesValue(AndRHS->getType()); Constant *ShlMask = ConstantExpr::getShl(AllOne, OpRHS); Constant *CI = ConstantExpr::getAnd(AndRHS, ShlMask); - + if (CI == ShlMask) { // Masking out bits that the shift already masks return ReplaceInstUsesWith(TheAnd, Op); // No need for the and. } else if (CI != AndRHS) { // Reducing bits set in and. @@ -1476,7 +1476,7 @@ Instruction *InstCombiner::OptAndOp(Instruction *Op, return &TheAnd; } break; - } + } case Instruction::Shr: // We know that the AND will not produce any of the bits shifted in, so if // the anded constant includes them, clear them now! This only applies to @@ -1536,7 +1536,7 @@ Instruction *InstCombiner::InsertRangeTest(Value *V, Constant *Lo, Constant *Hi, return new SetCondInst(Instruction::SetNE, V, V); if (cast<ConstantIntegral>(Lo)->isMinValue()) return new SetCondInst(Instruction::SetLT, V, Hi); - + Constant *AddCST = ConstantExpr::getNeg(Lo); Instruction *Add = BinaryOperator::createAdd(V, AddCST,V->getName()+".off"); InsertNewInstBefore(Add, IB); @@ -1589,9 +1589,9 @@ Instruction *InstCombiner::visitAnd(BinaryOperator &I) { // If the mask is not masking out any bits, there is no reason to do the // and in the first place. - ConstantIntegral *NotAndRHS = + ConstantIntegral *NotAndRHS = cast<ConstantIntegral>(ConstantExpr::getNot(AndRHS)); - if (MaskedValueIsZero(Op0, NotAndRHS)) + if (MaskedValueIsZero(Op0, NotAndRHS)) return ReplaceInstUsesWith(I, Op0); // Optimize a variety of ((val OP C1) & C2) combinations... @@ -1605,9 +1605,9 @@ Instruction *InstCombiner::visitAnd(BinaryOperator &I) { // (X ^ V) & C2 --> (X & C2) iff (V & C2) == 0 // (X | V) & C2 --> (X & C2) iff (V & C2) == 0 if (MaskedValueIsZero(Op0LHS, AndRHS)) - return BinaryOperator::createAnd(Op0RHS, AndRHS); + return BinaryOperator::createAnd(Op0RHS, AndRHS); if (MaskedValueIsZero(Op0RHS, AndRHS)) - return BinaryOperator::createAnd(Op0LHS, AndRHS); + return BinaryOperator::createAnd(Op0LHS, AndRHS); // If the mask is only needed on one incoming arm, push it up. if (Op0I->hasOneUse()) { @@ -1618,7 +1618,7 @@ Instruction *InstCombiner::visitAnd(BinaryOperator &I) { InsertNewInstBefore(NewRHS, I); return BinaryOperator::create( cast<BinaryOperator>(Op0I)->getOpcode(), Op0LHS, NewRHS); - } + } if (!isa<Constant>(NotAndRHS) && MaskedValueIsZero(Op0RHS, NotAndRHS)) { // Not masking anything out for the RHS, move to LHS. @@ -1727,7 +1727,7 @@ Instruction *InstCombiner::visitAnd(BinaryOperator &I) { if (match(RHS, m_SetCond(RHSCC, m_Value(RHSVal), m_ConstantInt(RHSCst)))) if (LHSVal == RHSVal && // Found (X setcc C1) & (X setcc C2) // Set[GL]E X, CST is folded to Set[GL]T elsewhere. - LHSCC != Instruction::SetGE && LHSCC != Instruction::SetLE && + LHSCC != Instruction::SetGE && LHSCC != Instruction::SetLE && RHSCC != Instruction::SetGE && RHSCC != Instruction::SetLE) { // Ensure that the larger constant is on the RHS. Constant *Cmp = ConstantExpr::getSetGT(LHSCst, RHSCst); @@ -1869,7 +1869,7 @@ Instruction *InstCombiner::visitOr(BinaryOperator &I) { if (match(Op0, m_Not(m_Value(A)))) { // ~A | Op1 if (A == Op1) // ~A | A == -1 - return ReplaceInstUsesWith(I, + return ReplaceInstUsesWith(I, ConstantIntegral::getAllOnesValue(I.getType())); } else { A = 0; @@ -1877,7 +1877,7 @@ Instruction *InstCombiner::visitOr(BinaryOperator &I) { if (match(Op1, m_Not(m_Value(B)))) { // Op0 | ~B if (Op0 == B) - return ReplaceInstUsesWith(I, + return ReplaceInstUsesWith(I, ConstantIntegral::getAllOnesValue(I.getType())); // (~A | ~B) == (~(A & B)) - De Morgan's Law @@ -1900,7 +1900,7 @@ Instruction *InstCombiner::visitOr(BinaryOperator &I) { if (match(RHS, m_SetCond(RHSCC, m_Value(RHSVal), m_ConstantInt(RHSCst)))) if (LHSVal == RHSVal && // Found (X setcc C1) | (X setcc C2) // Set[GL]E X, CST is folded to Set[GL]T elsewhere. - LHSCC != Instruction::SetGE && LHSCC != Instruction::SetLE && + LHSCC != Instruction::SetGE && LHSCC != Instruction::SetLE && RHSCC != Instruction::SetGE && RHSCC != Instruction::SetLE) { // Ensure that the larger constant is on the RHS. Constant *Cmp = ConstantExpr::getSetGT(LHSCst, RHSCst); @@ -2035,13 +2035,13 @@ Instruction *InstCombiner::visitXor(BinaryOperator &I) { if (dyn_castNotVal(Op0I->getOperand(1))) Op0I->swapOperands(); if (Value *Op0NotVal = dyn_castNotVal(Op0I->getOperand(0))) { Instruction *NotY = - BinaryOperator::createNot(Op0I->getOperand(1), + BinaryOperator::createNot(Op0I->getOperand(1), Op0I->getOperand(1)->getName()+".not"); InsertNewInstBefore(NotY, I); return BinaryOperator::createOr(Op0NotVal, NotY); } } - + if (ConstantInt *Op0CI = dyn_cast<ConstantInt>(Op0I->getOperand(1))) switch (Op0I->getOpcode()) { case Instruction::Add: @@ -2096,7 +2096,7 @@ Instruction *InstCombiner::visitXor(BinaryOperator &I) { } else if (Op1I->getOperand(1) == Op0) { // B^(A|B) == (A|B)^B I.swapOperands(); std::swap(Op0, Op1); - } + } } else if (Op1I->getOpcode() == Instruction::Xor) { if (Op0 == Op1I->getOperand(0)) // A^(A^B) == B return ReplaceInstUsesWith(I, Op1I->getOperand(1)); @@ -2242,13 +2242,13 @@ Instruction *InstCombiner::FoldGEPSetCC(User *GEPLHS, Value *RHS, EmitIt = false; else if (TD->getTypeSize(GTI.getIndexedType()) == 0) { EmitIt = false; // This is indexing into a zero sized array? - } else if (isa<ConstantInt>(C)) + } else if (isa<ConstantInt>(C)) return ReplaceInstUsesWith(I, // No comparison is needed here. ConstantBool::get(Cond == Instruction::SetNE)); } if (EmitIt) { - Instruction *Comp = + Instruction *Comp = new SetCondInst(Cond, GEPLHS->getOperand(i), Constant::getNullValue(GEPLHS->getOperand(i)->getType())); if (InVal == 0) @@ -2312,7 +2312,7 @@ Instruction *InstCombiner::FoldGEPSetCC(User *GEPLHS, Value *RHS, unsigned DiffOperand = 0; // The operand that differs. for (unsigned i = 1, e = GEPRHS->getNumOperands(); i != e; ++i) if (GEPLHS->getOperand(i) != GEPRHS->getOperand(i)) { - if (GEPLHS->getOperand(i)->getType()->getPrimitiveSize() != + if (GEPLHS->getOperand(i)->getType()->getPrimitiveSize() != GEPRHS->getOperand(i)->getType()->getPrimitiveSize()) { // Irreconcilable differences. NumDifferences = 2; @@ -2364,9 +2364,9 @@ Instruction *InstCombiner::visitSetCondInst(BinaryOperator &I) { // setcc <global/alloca*/null>, <global/alloca*/null> - Global/Stack value // addresses never equal each other! We already know that Op0 != Op1. - if ((isa<GlobalValue>(Op0) || isa<AllocaInst>(Op0) || - isa<ConstantPointerNull>(Op0)) && - (isa<GlobalValue>(Op1) || isa<AllocaInst>(Op1) || + if ((isa<GlobalValue>(Op0) || isa<AllocaInst>(Op0) || + isa<ConstantPointerNull>(Op0)) && + (isa<GlobalValue>(Op1) || isa<AllocaInst>(Op1) || isa<ConstantPointerNull>(Op1))) return ReplaceInstUsesWith(I, ConstantBool::get(!isTrueWhenEqual(I))); @@ -2466,7 +2466,7 @@ Instruction *InstCombiner::visitSetCondInst(BinaryOperator &I) { ShAmt = Shift ? dyn_cast<ConstantUInt>(Shift->getOperand(1)) : 0; ConstantInt *AndCST = cast<ConstantInt>(LHSI->getOperand(1)); const Type *Ty = LHSI->getType(); - + // We can fold this as long as we can't shift unknown bits // into the mask. This can only happen with signed shift // rights, as they sign-extend. @@ -2476,14 +2476,14 @@ Instruction *InstCombiner::visitSetCondInst(BinaryOperator &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. - Constant *OShAmt = ConstantUInt::get(Type::UByteTy, + Constant *OShAmt = ConstantUInt::get(Type::UByteTy, Ty->getPrimitiveSize()*8-ShAmt->getValue()); - Constant *ShVal = + Constant *ShVal = ConstantExpr::getShl(ConstantInt::getAllOnesValue(Ty), OShAmt); if (ConstantExpr::getAnd(ShVal, AndCST)->isNullValue()) CanFold = true; } - + if (CanFold) { Constant *NewCst; if (Shift->getOpcode() == Instruction::Shl) @@ -2521,7 +2521,7 @@ Instruction *InstCombiner::visitSetCondInst(BinaryOperator &I) { // (setcc (cast X to larger), CI) case Instruction::Cast: - if (Instruction *R = + if (Instruction *R = visitSetCondInstWithCastAndConstant(I,cast<CastInst>(LHSI),CI)) return R; break; @@ -2534,7 +2534,7 @@ Instruction *InstCombiner::visitSetCondInst(BinaryOperator &I) { case Instruction::SetNE: { // If we are comparing against bits always shifted out, the // comparison cannot succeed. - Constant *Comp = + Constant *Comp = ConstantExpr::getShl(ConstantExpr::getShr(CI, ShAmt), ShAmt); if (Comp != CI) {// Comparing against a bit that we know is zero. bool IsSetNE = I.getOpcode() == Instruction::SetNE; @@ -2556,7 +2556,7 @@ Instruction *InstCombiner::visitSetCondInst(BinaryOperator &I) { } else { Mask = ConstantInt::getAllOnesValue(CI->getType()); } - + Instruction *AndI = BinaryOperator::createAnd(LHSI->getOperand(0), Mask, LHSI->getName()+".mask"); @@ -2577,15 +2577,15 @@ Instruction *InstCombiner::visitSetCondInst(BinaryOperator &I) { case Instruction::SetNE: { // If we are comparing against bits always shifted out, the // comparison cannot succeed. - Constant *Comp = + Constant *Comp = ConstantExpr::getShr(ConstantExpr::getShl(CI, ShAmt), ShAmt); - + if (Comp != CI) {// Comparing against a bit that we know is zero. bool IsSetNE = I.getOpcode() == Instruction::SetNE; Constant *Cst = ConstantBool::get(IsSetNE); return ReplaceInstUsesWith(I, Cst); } - + if (LHSI->hasOneUse() || CI->isNullValue()) { unsigned ShAmtVal = (unsigned)ShAmt->getValue(); @@ -2602,7 +2602,7 @@ Instruction *InstCombiner::visitSetCondInst(BinaryOperator &I) { } else { Mask = ConstantSInt::get(CI->getType(), Val); } - + Instruction *AndI = BinaryOperator::createAnd(LHSI->getOperand(0), Mask, LHSI->getName()+".mask"); @@ -2727,12 +2727,12 @@ Instruction *InstCombiner::visitSetCondInst(BinaryOperator &I) { I.getName()), I); } } - + if (Op1) return new SelectInst(LHSI->getOperand(0), Op1, Op2); break; } - + // Simplify seteq and setne instructions... if (I.getOpcode() == Instruction::SetEQ || I.getOpcode() == Instruction::SetNE) { @@ -2758,7 +2758,7 @@ Instruction *InstCombiner::visitSetCondInst(BinaryOperator &I) { return BinaryOperator::create(I.getOpcode(), NewRem, Constant::getNullValue(UTy)); } - break; + break; case Instruction::Add: // Replace ((add A, B) != C) with (A != C-B) if B & C are constants. @@ -2770,7 +2770,7 @@ Instruction *InstCombiner::visitSetCondInst(BinaryOperator &I) { // Replace ((add A, B) != 0) with (A != -B) if A or B is // efficiently invertible, or if the add has just this one use. Value *BOp0 = BO->getOperand(0), *BOp1 = BO->getOperand(1); - + if (Value *NegVal = dyn_castNegVal(BOp1)) return new SetCondInst(I.getOpcode(), BOp0, NegVal); else if (Value *NegVal = dyn_castNegVal(BOp0)) @@ -2835,7 +2835,7 @@ Instruction *InstCombiner::visitSetCondInst(BinaryOperator &I) { Instruction::SetGE, X, Constant::getNullValue(X->getType())); } - + // ((X & ~7) == 0) --> X < 8 if (CI->isNullValue() && isHighOnes(BOC)) { Value *X = BO->getOperand(0); @@ -2857,14 +2857,14 @@ Instruction *InstCombiner::visitSetCondInst(BinaryOperator &I) { } } } else { // Not a SetEQ/SetNE - // If the LHS is a cast from an integral value of the same size, + // If the LHS is a cast from an integral value of the same size, if (CastInst *Cast = dyn_cast<CastInst>(Op0)) { Value *CastOp = Cast->getOperand(0); const Type *SrcTy = CastOp->getType(); unsigned SrcTySize = SrcTy->getPrimitiveSize(); if (SrcTy != Cast->getType() && SrcTy->isInteger() && SrcTySize == Cast->getType()->getPrimitiveSize()) { - assert((SrcTy->isSigned() ^ Cast->getType()->isSigned()) && + assert((SrcTy->isSigned() ^ Cast->getType()->isSigned()) && "Source and destination signednesses should differ!"); if (Cast->getType()->isSigned()) { // If this is a signed comparison, check for comparisons in the @@ -2916,14 +2916,14 @@ Instruction *InstCombiner::visitSetCondInst(BinaryOperator &I) { // We keep moving the cast from the left operand over to the right // operand, where it can often be eliminated completely. Op0 = CastOp0; - + // If operand #1 is a cast instruction, see if we can eliminate it as // well. if (CastInst *CI2 = dyn_cast<CastInst>(Op1)) if (CI2->getOperand(0)->getType()->isLosslesslyConvertibleTo( Op0->getType())) Op1 = CI2->getOperand(0); - + // If Op1 is a constant, we can fold the cast into the constant. if (Op1->getType() != Op0->getType()) if (Constant *Op1C = dyn_cast<Constant>(Op1)) { @@ -2978,7 +2978,7 @@ Instruction *InstCombiner::visitSetCondInst(BinaryOperator &I) { return ReplaceInstUsesWith(I, ConstantBool::False); } } - + // Otherwise, we can replace the setcc with a setcc of the smaller // operand value. Op1 = ConstantExpr::getCast(cast<Constant>(Op1), SrcTy); @@ -2989,10 +2989,10 @@ Instruction *InstCombiner::visitSetCondInst(BinaryOperator &I) { return Changed ? &I : 0; } -// visitSetCondInstWithCastAndConstant - this method is part of the +// visitSetCondInstWithCastAndConstant - this method is part of the // visitSetCondInst method. It handles the situation where we have: // (setcc (cast X to larger), CI) -// It tries to remove the cast and even the setcc if the CI value +// It tries to remove the cast and even the setcc if the CI value // and range of the cast allow it. Instruction * InstCombiner::visitSetCondInstWithCastAndConstant(BinaryOperator&I, @@ -3005,9 +3005,9 @@ InstCombiner::visitSetCondInstWithCastAndConstant(BinaryOperator&I, unsigned SrcBits = SrcTy->getPrimitiveSize()*8; unsigned DestBits = DestTy->getPrimitiveSize()*8; - if (SrcTy == Type::BoolTy) + if (SrcTy == Type::BoolTy) SrcBits = 1; - if (DestTy == Type::BoolTy) + if (DestTy == Type::BoolTy) DestBits = 1; if (SrcBits < DestBits) { // There are fewer bits in the source of the cast than in the result @@ -3015,25 +3015,25 @@ InstCombiner::visitSetCondInstWithCastAndConstant(BinaryOperator&I, // value won't have changed due to sign extension. Constant *NewCst = ConstantExpr::getCast(CI, SrcTy); if (ConstantExpr::getCast(NewCst, DestTy) == CI) { - // The constant value operand of the setCC before and after a - // cast to the source type of the cast instruction is the same - // value, so we just replace with the same setcc opcode, but - // using the source value compared to the constant casted to the - // source type. + // The constant value operand of the setCC before and after a + // cast to the source type of the cast instruction is the same + // value, so we just replace with the same setcc opcode, but + // using the source value compared to the constant casted to the + // source type. if (SrcTy->isSigned() && DestTy->isUnsigned()) { CastInst* Cst = new CastInst(LHSI->getOperand(0), SrcTy->getUnsignedVersion(), LHSI->getName()); InsertNewInstBefore(Cst,I); - return new SetCondInst(I.getOpcode(), Cst, + return new SetCondInst(I.getOpcode(), Cst, ConstantExpr::getCast(CI, SrcTy->getUnsignedVersion())); } return new SetCondInst(I.getOpcode(), LHSI->getOperand(0),NewCst); } - // The constant value before and after a cast to the source type - // is different, so various cases are possible depending on the + // The constant value before and after a cast to the source type + // is different, so various cases are possible depending on the // opcode and the signs of the types involved in the cast. switch (I.getOpcode()) { case Instruction::SetLT: { @@ -3052,14 +3052,14 @@ InstCombiner::visitSetCondInstWithCastAndConstant(BinaryOperator&I, // We're looking for equality, and we know the values are not // equal so replace with constant False. return ReplaceInstUsesWith(I, ConstantBool::False); - case Instruction::SetNE: + case Instruction::SetNE: // We're testing for inequality, and we know the values are not // equal so replace with constant True. return ReplaceInstUsesWith(I, ConstantBool::True); - case Instruction::SetLE: - case Instruction::SetGE: + case Instruction::SetLE: + case Instruction::SetGE: assert(0 && "SetLE and SetGE should be handled elsewhere"); - default: + default: assert(0 && "unknown integer comparison"); } } @@ -3123,7 +3123,7 @@ Instruction *InstCombiner::visitShiftInst(ShiftInst &I) { if (Constant *BOOp = dyn_cast<Constant>(BO->getOperand(1))) return BinaryOperator::createMul(BO->getOperand(0), ConstantExpr::getShl(BOOp, CUI)); - + // Try to fold constant and into select arguments. if (SelectInst *SI = dyn_cast<SelectInst>(Op0)) if (Instruction *R = FoldOpIntoSelect(I, SI, this)) @@ -3219,7 +3219,7 @@ Instruction *InstCombiner::visitShiftInst(ShiftInst &I) { dyn_cast<ConstantUInt>(Op0SI->getOperand(1))) { unsigned ShiftAmt1 = (unsigned)ShiftAmt1C->getValue(); unsigned ShiftAmt2 = (unsigned)CUI->getValue(); - + // Check for (A << c1) << c2 and (A >> c1) >> c2 if (I.getOpcode() == Op0SI->getOpcode()) { unsigned Amt = ShiftAmt1+ShiftAmt2; // Fold into one big shift... @@ -3228,7 +3228,7 @@ Instruction *InstCombiner::visitShiftInst(ShiftInst &I) { return new ShiftInst(I.getOpcode(), Op0SI->getOperand(0), ConstantUInt::get(Type::UByteTy, Amt)); } - + // Check for (A << c1) >> c2 or visaversa. If we are dealing with // signed types, we can only support the (A >> c1) << c2 configuration, // because it can not turn an arbitrary bit of A into a sign bit. @@ -3239,12 +3239,12 @@ Instruction *InstCombiner::visitShiftInst(ShiftInst &I) { C = ConstantExpr::getShl(C, ShiftAmt1C); else C = ConstantExpr::getShr(C, ShiftAmt1C); - + Instruction *Mask = BinaryOperator::createAnd(Op0SI->getOperand(0), C, Op0SI->getOperand(0)->getName()+".mask"); InsertNewInstBefore(Mask, I); - + // Figure out what flavor of shift we should use... if (ShiftAmt1 == ShiftAmt2) return ReplaceInstUsesWith(I, Mask); // (A << c) >> c === A & c2 @@ -3293,7 +3293,7 @@ static inline bool isEliminableCastOfCast(const Type *SrcTy, const Type *MidTy, const Type *DstTy, TargetData *TD) { // It is legal to eliminate the instruction if casting A->B->A if the sizes - // are identical and the bits don't get reinterpreted (for example + // are identical and the bits don't get reinterpreted (for example // int->float->int would not be allowed). if (SrcTy == DstTy && SrcTy->isLosslesslyConvertibleTo(MidTy)) return true; @@ -3341,7 +3341,7 @@ static inline bool isEliminableCastOfCast(const Type *SrcTy, const Type *MidTy, CastType ResultCast = getCastType(SrcTy, DstTy); if (ResultCast == Noop || ResultCast == Truncate) return true; - // Otherwise we are still growing the value, we are only safe if the + // Otherwise we are still growing the value, we are only safe if the // result will match the sign/zeroextendness of the result. return ResultCast == FirstCast; } @@ -3402,7 +3402,7 @@ Instruction *InstCombiner::visitCastInst(CastInst &CI) { // If this is an A->B->A cast, and we are dealing with integral types, try // to convert this into a logical 'and' instruction. // - if (A->getType()->isInteger() && + if (A->getType()->isInteger() && CI.getType()->isInteger() && CSrc->getType()->isInteger() && CSrc->getType()->isUnsigned() && // B->A cast must zero extend CSrc->getType()->getPrimitiveSize() < CI.getType()->getPrimitiveSize()&& @@ -3422,7 +3422,7 @@ Instruction *InstCombiner::visitCastInst(CastInst &CI) { return And; } } - + // If this is a cast to bool, turn it into the appropriate setne instruction. if (CI.getType() == Type::BoolTy) return BinaryOperator::createSetNE(CI.getOperand(0), @@ -3460,7 +3460,7 @@ Instruction *InstCombiner::visitCastInst(CastInst &CI) { // If the allocation is for an even multiple of the cast type size if (CastElTySize && (AllocElTySize % CastElTySize == 0)) { - Value *Amt = ConstantUInt::get(Type::UIntTy, + Value *Amt = ConstantUInt::get(Type::UIntTy, AllocElTySize/CastElTySize); std::string Name = AI->getName(); AI->setName(""); AllocationInst *New; @@ -3527,7 +3527,7 @@ Instruction *InstCombiner::visitCastInst(CastInst &CI) { break; } } - + return 0; } @@ -3553,7 +3553,7 @@ static unsigned GetSelectFoldableOperands(Instruction *I) { case Instruction::Sub: // Can only fold on the amount subtracted. case Instruction::Shl: // Can only fold on the shift amount. case Instruction::Shr: - return 1; + return 1; default: return 0; // Cannot fold } @@ -3592,7 +3592,7 @@ Instruction *InstCombiner::FoldSelectOpOp(SelectInst &SI, Instruction *TI, } else { return 0; // unknown unary op. } - + // Fold this by inserting a select from the input values. SelectInst *NewSI = new SelectInst(SI.getCondition(), TI->getOperand(0), FI->getOperand(0), SI.getName()+".v"); @@ -3732,9 +3732,9 @@ Instruction *InstCombiner::visitSelectInst(SelectInst &SI) { cast<Constant>(IC->getOperand(1))->isNullValue()) if (Instruction *ICA = dyn_cast<Instruction>(IC->getOperand(0))) if (ICA->getOpcode() == Instruction::And && - isa<ConstantInt>(ICA->getOperand(1)) && - (ICA->getOperand(1) == TrueValC || - ICA->getOperand(1) == FalseValC) && + isa<ConstantInt>(ICA->getOperand(1)) && + (ICA->getOperand(1) == TrueValC || + ICA->getOperand(1) == FalseValC) && isOneBitSet(cast<ConstantInt>(ICA->getOperand(1)))) { // Okay, now we know that everything is set up, we just don't // know whether we have a setne or seteq and whether the true or @@ -3770,7 +3770,7 @@ Instruction *InstCombiner::visitSelectInst(SelectInst &SI) { // NOTE: if we wanted to, this is where to detect MIN/MAX/ABS/etc. } } - + if (Instruction *TI = dyn_cast<Instruction>(TrueVal)) if (Instruction *FI = dyn_cast<Instruction>(FalseVal)) if (TI->hasOneUse() && FI->hasOneUse()) { @@ -3821,14 +3821,14 @@ Instruction *InstCombiner::visitSelectInst(SelectInst &SI) { std::swap(NewTrueOp, NewFalseOp); Instruction *NewSel = new SelectInst(CondVal, NewTrueOp,NewFalseOp,SI.getName()+".p"); - + NewSel = InsertNewInstBefore(NewSel, SI); return BinaryOperator::createAdd(SubOp->getOperand(0), NewSel); } } } } - + // See if we can fold the select into one of our operands. if (SI.getType()->isInteger()) { // See the comment above GetSelectFoldableOperands for a description of the @@ -3906,7 +3906,7 @@ Instruction *InstCombiner::visitCallInst(CallInst &CI) { if (NumBytes->isNullValue()) return EraseInstFromFunction(CI); // FIXME: Increase alignment here. - + if (ConstantInt *CI = dyn_cast<ConstantInt>(NumBytes)) if (CI->getRawValue() == 1) { // Replace the instruction with just byte operations. We would @@ -3998,7 +3998,7 @@ Instruction *InstCombiner::visitCallSite(CallSite CS) { } } } - + return Changed ? CS.getInstruction() : 0; } @@ -4043,12 +4043,12 @@ bool InstCombiner::transformConstExprCastCall(CallSite CS) { unsigned NumActualArgs = unsigned(CS.arg_end()-CS.arg_begin()); unsigned NumCommonArgs = std::min(FT->getNumParams(), NumActualArgs); - + CallSite::arg_iterator AI = CS.arg_begin(); for (unsigned i = 0, e = NumCommonArgs; i != e; ++i, ++AI) { const Type *ParamTy = FT->getParamType(i); bool isConvertible = (*AI)->getType()->isLosslesslyConvertibleTo(ParamTy); - if (Callee->isExternal() && !isConvertible) return false; + if (Callee->isExternal() && !isConvertible) return false; } if (FT->getNumParams() < NumActualArgs && !FT->isVarArg() && @@ -4200,7 +4200,7 @@ Instruction *InstCombiner::FoldPHIArgOpIntoPHI(PHINode &PN) { InsertNewInstBefore(NewPN, PN); PhiVal = NewPN; } - + // Insert and return the new operation. if (isa<CastInst>(FirstInst)) return new CastInst(PhiVal, PN.getType()); @@ -4223,7 +4223,7 @@ static bool DeadPHICycle(PHINode *PN, std::set<PHINode*> &PotentiallyDeadPHIs) { if (PHINode *PU = dyn_cast<PHINode>(PN->use_back())) return DeadPHICycle(PU, PotentiallyDeadPHIs); - + return false; } @@ -4295,7 +4295,7 @@ Instruction *InstCombiner::visitPHINode(PHINode &PN) { if (DeadPHICycle(PU, PotentiallyDeadPHIs)) return ReplaceInstUsesWith(PN, UndefValue::get(PN.getType())); } - + return 0; } @@ -4353,7 +4353,7 @@ Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) { // We can always eliminate a cast from int to [u]long. We can // eliminate a cast from uint to [u]long iff the target is a 32-bit // pointer target. - if (SrcTy->isSigned() || + if (SrcTy->isSigned() || SrcTy->getPrimitiveSize() >= TD->getPointerSize()) { MadeChange = true; GEP.setOperand(i, Src); @@ -4412,7 +4412,7 @@ Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) { for (gep_type_iterator I = gep_type_begin(*cast<User>(PtrOp)), E = gep_type_end(*cast<User>(PtrOp)); I != E; ++I) EndsWithSequential = !isa<StructType>(*I); - + // Can we combine the two pointer arithmetics offsets? if (EndsWithSequential) { // Replace: gep (gep %P, long B), long A, ... @@ -4466,9 +4466,9 @@ Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) { Indices.push_back(Sum); Indices.insert(Indices.end(), GEP.op_begin()+2, GEP.op_end()); } - } else if (isa<Constant>(*GEP.idx_begin()) && + } else if (isa<Constant>(*GEP.idx_begin()) && cast<Constant>(*GEP.idx_begin())->isNullValue() && - SrcGEPOperands.size() != 1) { + SrcGEPOperands.size() != 1) { // Otherwise we can do the fold if the first index of the GEP is a zero Indices.insert(Indices.end(), SrcGEPOperands.begin()+1, SrcGEPOperands.end()); @@ -4526,7 +4526,7 @@ Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) { const Type *SrcElTy = cast<PointerType>(X->getType())->getElementType(); const Type *ResElTy =cast<PointerType>(CE->getType())->getElementType(); if (isa<ArrayType>(SrcElTy) && - TD->getTypeSize(cast<ArrayType>(SrcElTy)->getElementType()) == + TD->getTypeSize(cast<ArrayType>(SrcElTy)->getElementType()) == TD->getTypeSize(ResElTy)) { Value *V = InsertNewInstBefore( new GetElementPtrInst(X, Constant::getNullValue(Type::IntTy), @@ -4556,7 +4556,7 @@ Instruction *InstCombiner::visitAllocationInst(AllocationInst &AI) { } InsertNewInstBefore(New, AI); - + // Scan to the end of the allocation instructions, to skip over a block of // allocas if possible... // @@ -4579,7 +4579,7 @@ Instruction *InstCombiner::visitAllocationInst(AllocationInst &AI) { // If alloca'ing a zero byte object, replace the alloca with a null pointer. // Note that we only do this for alloca's, because malloc should allocate and // return a unique pointer, even for a zero byte allocation. - if (isa<AllocaInst>(AI) && AI.getAllocatedType()->isSized() && + if (isa<AllocaInst>(AI) && AI.getAllocatedType()->isSized() && TD->getTypeSize(AI.getAllocatedType()) == 0) return ReplaceInstUsesWith(AI, Constant::getNullValue(AI.getType())); @@ -4682,9 +4682,9 @@ static Instruction *InstCombineLoadCast(InstCombiner &IC, LoadInst &LI) { // Do not allow turning this into a load of an integer, which is then // casted to a pointer, this pessimizes pointer analysis a lot. (isa<PointerType>(SrcPTy) == isa<PointerType>(LI.getType())) && - IC.getTargetData().getTypeSize(SrcPTy) == + IC.getTargetData().getTypeSize(SrcPTy) == IC.getTargetData().getTypeSize(DestPTy)) { - + // Okay, we are casting from one integer or pointer type to another of // the same size. Instead of casting the pointer before the load, cast // the result of the loaded value. @@ -4721,7 +4721,7 @@ static bool isSafeToLoadUnconditionally(Value *V, Instruction *ScanFrom) { if (LI->getOperand(0) == V) return true; } else if (StoreInst *SI = dyn_cast<StoreInst>(BBI)) if (SI->getOperand(1) == V) return true; - + } return false; } @@ -4743,7 +4743,7 @@ Instruction *InstCombiner::visitLoadInst(LoadInst &LI) { if (GlobalVariable *GV = dyn_cast<GlobalVariable>(Op)) if (GV->isConstant() && !GV->isExternal()) return ReplaceInstUsesWith(LI, GV->getInitializer()); - + // Instcombine load (constantexpr_GEP global, 0, ...) into the value loaded. if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Op)) if (CE->getOpcode() == Instruction::GetElementPtr) { @@ -4867,7 +4867,7 @@ static Instruction *InstCombineStoreToCast(InstCombiner &IC, StoreInst &SI) { } if ((SrcPTy->isInteger() || isa<PointerType>(SrcPTy)) && - IC.getTargetData().getTypeSize(SrcPTy) == + IC.getTargetData().getTypeSize(SrcPTy) == IC.getTargetData().getTypeSize(DestPTy)) { // Okay, we are casting from one integer or pointer type to another of @@ -4967,7 +4967,7 @@ Instruction *InstCombiner::visitBranchInst(BranchInst &BI) { WorkList.push_back(cast<Instruction>(NewSCC)); return &BI; } - + return 0; } @@ -5004,7 +5004,7 @@ static bool TryToSinkInstruction(Instruction *I, BasicBlock *DestBlock) { // Cannot move control-flow-involving instructions. if (isa<PHINode>(I) || isa<InvokeInst>(I) || isa<CallInst>(I)) return false; - + // Do not sink alloca instructions out of the entry block. if (isa<AllocaInst>(I) && I->getParent() == &DestBlock->getParent()->front()) return false; @@ -5024,7 +5024,7 @@ static bool TryToSinkInstruction(Instruction *I, BasicBlock *DestBlock) { while (isa<PHINode>(InsertPos)) ++InsertPos; BasicBlock *SrcBlock = I->getParent(); - DestBlock->getInstList().splice(InsertPos, SrcBlock->getInstList(), I); + DestBlock->getInstList().splice(InsertPos, SrcBlock->getInstList(), I); ++NumSunkInst; return true; } @@ -5165,7 +5165,7 @@ bool InstCombiner::runOnFunction(Function &F) { for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) if (Instruction *OpI = dyn_cast<Instruction>(I->getOperand(i))) WorkList.push_back(OpI); - + // Instructions may end up in the worklist more than once. Erase all // occurrances of this instruction. removeFromWorkList(I); diff --git a/lib/Transforms/Scalar/LICM.cpp b/lib/Transforms/Scalar/LICM.cpp index 8807398..3f19051 100644 --- a/lib/Transforms/Scalar/LICM.cpp +++ b/lib/Transforms/Scalar/LICM.cpp @@ -1,10 +1,10 @@ //===-- LICM.cpp - Loop Invariant Code Motion Pass ------------------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This pass performs loop invariant code motion, attempting to remove as much @@ -89,7 +89,7 @@ namespace { Loop *CurLoop; // The current loop we are working on... AliasSetTracker *CurAST; // AliasSet information for the current loop... - /// visitLoop - Hoist expressions out of the specified loop... + /// visitLoop - Hoist expressions out of the specified loop... /// void visitLoop(Loop *L, AliasSetTracker &AST); @@ -131,21 +131,21 @@ namespace { BasicBlock *LoopHeader = CurLoop->getHeader(); if (BlockInLoop == LoopHeader) return true; - + DominatorTree::Node *BlockInLoopNode = DT->getNode(BlockInLoop); DominatorTree::Node *IDom = DT->getNode(ExitBlock); - + // Because the exit block is not in the loop, we know we have to get _at // least_ its immediate dominator. do { // Get next Immediate Dominator. IDom = IDom->getIDom(); - + // If we have got to the header of the loop, then the instructions block // did not dominate the exit node, so we can't hoist it. if (IDom->getBlock() == LoopHeader) return false; - + } while (IDom != BlockInLoopNode); return true; @@ -170,7 +170,7 @@ namespace { /// pointerInvalidatedByLoop - Return true if the body of this loop may /// store into the memory location pointed to by V. - /// + /// bool pointerInvalidatedByLoop(Value *V, unsigned Size) { // Check to see if any of the basic blocks in CurLoop invalidate *V. return CurAST->getAliasSetForPointer(V, Size).isMod(); @@ -222,7 +222,7 @@ bool LICM::runOnFunction(Function &) { } -/// visitLoop - Hoist expressions out of the specified loop... +/// visitLoop - Hoist expressions out of the specified loop... /// void LICM::visitLoop(Loop *L, AliasSetTracker &AST) { // Recurse through all subloops before we process this loop... @@ -296,7 +296,7 @@ void LICM::SinkRegion(DominatorTree::Node *N) { for (BasicBlock::iterator II = BB->end(); II != BB->begin(); ) { Instruction &I = *--II; - + // Check to see if we can sink this instruction to the exit blocks // of the loop. We can do this if the all users of the instruction are // outside of the loop. In this case, it doesn't even matter if the @@ -327,12 +327,12 @@ void LICM::HoistRegion(DominatorTree::Node *N) { if (!inSubLoop(BB)) for (BasicBlock::iterator II = BB->begin(), E = BB->end(); II != E; ) { Instruction &I = *II++; - + // Try hoisting the instruction out to the preheader. We can only do this // if all of the operands of the instruction are loop invariant and if it // is safe to hoist the instruction. // - if (isLoopInvariantInst(I) && canSinkOrHoistInst(I) && + if (isLoopInvariantInst(I) && canSinkOrHoistInst(I) && isSafeToExecuteUnconditionally(I)) hoist(I); } @@ -380,11 +380,11 @@ bool LICM::canSinkOrHoistInst(Instruction &I) { // FIXME: This should use mod/ref information to see if we can hoist or sink // the call. - + return false; } - return isa<BinaryOperator>(I) || isa<ShiftInst>(I) || isa<CastInst>(I) || + return isa<BinaryOperator>(I) || isa<ShiftInst>(I) || isa<CastInst>(I) || isa<SelectInst>(I) || isa<GetElementPtrInst>(I) || isa<VANextInst>(I) || isa<VAArgInst>(I); } @@ -452,7 +452,7 @@ void LICM::sink(Instruction &I) { // Move the instruction to the start of the exit block, after any PHI // nodes in it. I.getParent()->getInstList().remove(&I); - + BasicBlock::iterator InsertPt = ExitBlocks[0]->begin(); while (isa<PHINode>(InsertPt)) ++InsertPt; ExitBlocks[0]->getInstList().insert(InsertPt, &I); @@ -472,7 +472,7 @@ void LICM::sink(Instruction &I) { if (I.getType() != Type::VoidTy) AI = new AllocaInst(I.getType(), 0, I.getName(), I.getParent()->getParent()->front().begin()); - + // Secondly, insert load instructions for each use of the instruction // outside of the loop. while (!I.use_empty()) { @@ -519,7 +519,7 @@ void LICM::sink(Instruction &I) { // Insert the code after the last PHI node... BasicBlock::iterator InsertPt = ExitBlock->begin(); while (isa<PHINode>(InsertPt)) ++InsertPt; - + // If this is the first exit block processed, just move the original // instruction, otherwise clone the original instruction and insert // the copy. @@ -535,7 +535,7 @@ void LICM::sink(Instruction &I) { New->setName(I.getName()+".le"); ExitBlock->getInstList().insert(InsertPt, New); } - + // Now that we have inserted the instruction, store it into the alloca if (AI) new StoreInst(New, AI, InsertPt); } @@ -547,7 +547,7 @@ void LICM::sink(Instruction &I) { CurAST->deleteValue(&I); I.getParent()->getInstList().erase(&I); } - + // Finally, promote the fine value to SSA form. if (AI) { std::vector<AllocaInst*> Allocas; @@ -561,7 +561,7 @@ void LICM::sink(Instruction &I) { /// that is safe to hoist, this instruction is called to do the dirty work. /// void LICM::hoist(Instruction &I) { - DEBUG(std::cerr << "LICM hoisting to " << Preheader->getName() + DEBUG(std::cerr << "LICM hoisting to " << Preheader->getName() << ": " << I); // Remove the instruction from its current basic block... but don't delete the @@ -570,7 +570,7 @@ void LICM::hoist(Instruction &I) { // Insert the new node in Preheader, before the terminator. Preheader->getInstList().insert(Preheader->getTerminator(), &I); - + if (isa<LoadInst>(I)) ++NumMovedLoads; else if (isa<CallInst>(I)) ++NumMovedCalls; ++NumHoisted; @@ -584,7 +584,7 @@ void LICM::hoist(Instruction &I) { bool LICM::isSafeToExecuteUnconditionally(Instruction &Inst) { // If it is not a trapping instruction, it is always safe to hoist. if (!Inst.isTrapping()) return true; - + // Otherwise we have to check to make sure that the instruction dominates all // of the exit blocks. If it doesn't, then there is a path out of the loop // which does not execute this instruction, so we can't hoist it. @@ -610,7 +610,7 @@ bool LICM::isSafeToExecuteUnconditionally(Instruction &Inst) { for (unsigned i = 0, e = ExitBlocks.size(); i != e; ++i) if (!isExitBlockDominatedByBlockInLoop(ExitBlocks[i], Inst.getParent())) return false; - + return true; } @@ -672,7 +672,7 @@ void LICM::PromoteValuesInLoop() { // Store into the temporary alloca. new StoreInst(LI, PromotedValues[i].first, LoopPredInst); } - + // Scan the basic blocks in the loop, replacing uses of our pointers with // uses of the allocas in question. // @@ -777,10 +777,10 @@ void LICM::FindPromotableValuesInLoop( // Update the AST and alias analysis. CurAST->copyValue(V, AI); - + for (AliasSet::iterator I = AS.begin(), E = AS.end(); I != E; ++I) ValueToAllocaMap.insert(std::make_pair(I->first, AI)); - + DEBUG(std::cerr << "LICM: Promoting value: " << *V << "\n"); } } diff --git a/lib/Transforms/Scalar/LoopStrengthReduce.cpp b/lib/Transforms/Scalar/LoopStrengthReduce.cpp index 6c0290a..28ecb98 100644 --- a/lib/Transforms/Scalar/LoopStrengthReduce.cpp +++ b/lib/Transforms/Scalar/LoopStrengthReduce.cpp @@ -1,10 +1,10 @@ //===- LoopStrengthReduce.cpp - Strength Reduce GEPs in Loops -------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by Nate Begeman and is distributed under the // University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This pass performs a strength reduction on array references inside loops that @@ -85,7 +85,7 @@ namespace { std::set<Instruction*> &DeadInsts); void DeleteTriviallyDeadInstructions(std::set<Instruction*> &Insts); }; - RegisterOpt<LoopStrengthReduce> X("loop-reduce", + RegisterOpt<LoopStrengthReduce> X("loop-reduce", "Strength Reduce GEP Uses of Ind. Vars"); } @@ -170,7 +170,7 @@ void LoopStrengthReduce::strengthReduceGEP(GetElementPtrInst *GEPI, Loop *L, Cache = Cache->get(operand); } assert(indvar > 0 && "Indvar used by GEP not found in operand list"); - + // Ensure the pointer base is loop invariant. While strength reduction // makes sense even if the pointer changed on every iteration, there is no // realistic way of handling it unless GEPs were completely decomposed into @@ -185,9 +185,9 @@ void LoopStrengthReduce::strengthReduceGEP(GetElementPtrInst *GEPI, Loop *L, if (sz && (sz & (sz-1)) == 0) // Power of two? if (sz <= (1ULL << (MaxTargetAMSize-1))) return; - + // If all operands of the GEP we are going to insert into the preheader - // are constants, generate a GEP ConstantExpr instead. + // are constants, generate a GEP ConstantExpr instead. // // If there is only one operand after the initial non-constant one, we know // that it was the induction variable, and has been replaced by a constant @@ -202,7 +202,7 @@ void LoopStrengthReduce::strengthReduceGEP(GetElementPtrInst *GEPI, Loop *L, PreGEP = GEPI->getOperand(0); } else { PreGEP = new GetElementPtrInst(GEPI->getOperand(0), - pre_op_vector, GEPI->getName()+".pre", + pre_op_vector, GEPI->getName()+".pre", Preheader->getTerminator()); } @@ -210,15 +210,15 @@ void LoopStrengthReduce::strengthReduceGEP(GetElementPtrInst *GEPI, Loop *L, // choose between the initial GEP we created and inserted into the // preheader, and the incremented GEP that we will create below and insert // into the loop body. - NewPHI = new PHINode(PreGEP->getType(), + NewPHI = new PHINode(PreGEP->getType(), GEPI->getName()+".str", InsertBefore); NewPHI->addIncoming(PreGEP, Preheader); - + // Now, create the GEP instruction to increment by one the value selected // by the PHI instruction we just created above, and add it as the second // incoming Value/BasicBlock pair to the PHINode. It is inserted before // the increment of the canonical induction variable. - Instruction *IncrInst = + Instruction *IncrInst = const_cast<Instruction*>(L->getCanonicalInductionVariableIncrement()); GetElementPtrInst *StrGEP = new GetElementPtrInst(NewPHI, inc_op_vector, GEPI->getName()+".inc", @@ -233,7 +233,7 @@ void LoopStrengthReduce::strengthReduceGEP(GetElementPtrInst *GEPI, Loop *L, // about to create. NewPHI = Cache->CachedPHINode; } - + if (GEPI->getNumOperands() - 1 == indvar) { // If there were no operands following the induction variable, replace all // uses of the old GEP instruction with the new PHI. @@ -252,7 +252,7 @@ void LoopStrengthReduce::strengthReduceGEP(GetElementPtrInst *GEPI, Loop *L, GEPI); GEPI->replaceAllUsesWith(newGEP); } - + // The old GEP is now dead. DeadInsts.insert(GEPI); ++NumReduced; @@ -273,7 +273,7 @@ void LoopStrengthReduce::runOnLoop(Loop *L) { // pass creates code like this, which we can't currently detect: // %tmp.1 = sub uint 2000, %indvar // %tmp.8 = getelementptr int* %y, uint %tmp.1 - + // Strength reduce all GEPs in the Loop. Insert secondary PHI nodes for the // strength reduced pointers we'll be creating after the canonical induction // variable's PHI. diff --git a/lib/Transforms/Scalar/LoopUnroll.cpp b/lib/Transforms/Scalar/LoopUnroll.cpp index da80ee3..45b81f7 100644 --- a/lib/Transforms/Scalar/LoopUnroll.cpp +++ b/lib/Transforms/Scalar/LoopUnroll.cpp @@ -1,10 +1,10 @@ //===-- LoopUnroll.cpp - Loop unroller pass -------------------------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This pass implements a simple loop unroller. It works best when loops have @@ -88,7 +88,7 @@ static unsigned ApproximateLoopSize(const Loop *L) { } else if (I->hasOneUse() && I->use_back() == Term) { // Ignore instructions only used by the loop terminator. } else if (DbgInfoIntrinsic *DbgI = dyn_cast<DbgInfoIntrinsic>(I)) { - // Ignore debug instructions + // Ignore debug instructions } else { ++Size; } @@ -102,10 +102,10 @@ static unsigned ApproximateLoopSize(const Loop *L) { return Size; } -// RemapInstruction - Convert the instruction operands from referencing the +// RemapInstruction - Convert the instruction operands from referencing the // current values into those specified by ValueMap. // -static inline void RemapInstruction(Instruction *I, +static inline void RemapInstruction(Instruction *I, std::map<const Value *, Value*> &ValueMap) { for (unsigned op = 0, E = I->getNumOperands(); op != E; ++op) { Value *Op = I->getOperand(op); @@ -150,7 +150,7 @@ bool LoopUnroll::visitLoop(Loop *L) { return Changed; } DEBUG(std::cerr << "UNROLLING!\n"); - + unsigned TripCount = (unsigned)TripCountFull; BasicBlock *LoopExit = BI->getSuccessor(L->contains(BI->getSuccessor(0))); @@ -235,7 +235,7 @@ bool LoopUnroll::visitLoop(Loop *L) { PN->replaceAllUsesWith(PN->getIncomingValueForBlock(Preheader)); BB->getInstList().erase(PN); } - + // Finally, add an unconditional branch to the block to continue into the exit // block. new BranchInst(LoopExit, BB); @@ -245,7 +245,7 @@ bool LoopUnroll::visitLoop(Loop *L) { // go. for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ) { Instruction *Inst = I++; - + if (isInstructionTriviallyDead(Inst)) BB->getInstList().erase(Inst); else if (Constant *C = ConstantFoldInstruction(Inst)) { diff --git a/lib/Transforms/Scalar/LoopUnswitch.cpp b/lib/Transforms/Scalar/LoopUnswitch.cpp index 434b75b..e51e7f2 100644 --- a/lib/Transforms/Scalar/LoopUnswitch.cpp +++ b/lib/Transforms/Scalar/LoopUnswitch.cpp @@ -1,10 +1,10 @@ //===-- LoopUnswitch.cpp - Hoist loop-invariant conditionals in loop ------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This pass transforms loops that contain branches on loop-invariant conditions @@ -116,15 +116,15 @@ bool LoopUnswitch::visitLoop(Loop *L) { } else { // FIXME: check for profitability. //std::cerr << "BEFORE:\n"; LI->dump(); - + VersionLoop(BI->getCondition(), L); - + //std::cerr << "AFTER:\n"; LI->dump(); return true; } } } - + return Changed; } @@ -152,10 +152,10 @@ BasicBlock *LoopUnswitch::SplitBlock(BasicBlock *BB, bool SplitAtTop) { } -// RemapInstruction - Convert the instruction operands from referencing the +// RemapInstruction - Convert the instruction operands from referencing the // current values into those specified by ValueMap. // -static inline void RemapInstruction(Instruction *I, +static inline void RemapInstruction(Instruction *I, std::map<const Value *, Value*> &ValueMap) { for (unsigned op = 0, E = I->getNumOperands(); op != E; ++op) { Value *Op = I->getOperand(op); @@ -185,7 +185,7 @@ static Loop *CloneLoop(Loop *L, Loop *PL, std::map<const Value*, Value*> &VM, // Add all of the subloops to the new loop. for (Loop::iterator I = L->begin(), E = L->end(); I != E; ++I) CloneLoop(*I, New, VM, LI); - + return New; } @@ -210,7 +210,7 @@ InsertPHINodesForUsesOutsideLoop(Instruction *OI, Instruction *NI, !NL->contains(cast<Instruction>(*UI)->getParent())) goto UsedOutsideOfLoop; return 0; - + UsedOutsideOfLoop: // Okay, this instruction is used outside of the current loop. Insert a PHI // nodes for the instruction merging the values together. diff --git a/lib/Transforms/Scalar/LowerConstantExprs.cpp b/lib/Transforms/Scalar/LowerConstantExprs.cpp index 6de6c0d..cccf9e0 100644 --- a/lib/Transforms/Scalar/LowerConstantExprs.cpp +++ b/lib/Transforms/Scalar/LowerConstantExprs.cpp @@ -1,14 +1,14 @@ //===-- lib/Transforms/Scalar/LowerConstantExprs.cpp ------------*- C++ -*-===// -// +// // The LLVM Compiler Infrastructure // // This file was written by Vladimir Prus and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file defines the LowerConstantExpression pass, which converts all -// constant expressions into instructions. This is primarily usefull for +// constant expressions into instructions. This is primarily usefull for // code generators which don't yet want or don't have a need to handle // constant expressions themself. // @@ -29,18 +29,18 @@ namespace { class ConstantExpressionsLower : public FunctionPass { private: // FunctionPass overrides - + bool runOnFunction(Function& f); private: // internal methods /// For all operands of 'insn' which are constant expressions, generates - /// an appropriate instruction and replaces the use of constant + /// an appropriate instruction and replaces the use of constant /// expression with the use of the generated instruction. bool runOnInstruction(Instruction& insn); /// Given an constant expression 'c' which occures in 'instruction', - /// at position 'pos', + /// at position 'pos', /// generates instruction to compute 'c' and replaces the use of 'c' /// with the use of that instruction. This handles only top-level /// expression in 'c', any subexpressions are not handled. @@ -48,7 +48,7 @@ namespace { }; RegisterOpt<ConstantExpressionsLower> X( - "lowerconstantexprs", "Lower constant expressions"); + "lowerconstantexprs", "Lower constant expressions"); } bool ConstantExpressionsLower::runOnFunction(Function& f) @@ -66,14 +66,14 @@ bool ConstantExpressionsLower::runOnInstruction(Instruction& instruction) bool modified = false; for (unsigned pos = 0; pos < instruction.getNumOperands(); ++pos) { - if (ConstantExpr* ce + if (ConstantExpr* ce = dyn_cast<ConstantExpr>(instruction.getOperand(pos))) { // Decide where to insert the new instruction Instruction* where = &instruction; - // For PHI nodes we can't insert new instruction before phi, - // since phi should always come at the beginning of the + // For PHI nodes we can't insert new instruction before phi, + // since phi should always come at the beginning of the // basic block. // So, we need to insert it in the predecessor, right before // the terminating instruction. @@ -92,12 +92,12 @@ bool ConstantExpressionsLower::runOnInstruction(Instruction& instruction) // Note: we can't call replaceAllUsesWith, since // that might replace uses in another functions, // where the instruction(s) we've generated are not - // available. - - // Moreover, we can't replace all the users in the same - // function, because we can't be sure the definition + // available. + + // Moreover, we can't replace all the users in the same + // function, because we can't be sure the definition // made in this block will be available in other - // places where the constant is used. + // places where the constant is used. instruction.setOperand(pos, n); // The new instruction might have constant expressions in @@ -105,11 +105,11 @@ bool ConstantExpressionsLower::runOnInstruction(Instruction& instruction) runOnInstruction(*n); modified = true; } - } + } return modified; } -Instruction* +Instruction* ConstantExpressionsLower::convert(const ConstantExpr& c, Instruction* where) { Instruction* result = 0; @@ -118,13 +118,13 @@ ConstantExpressionsLower::convert(const ConstantExpr& c, Instruction* where) c.getOpcode() < Instruction::BinaryOpsEnd) { result = BinaryOperator::create( - static_cast<Instruction::BinaryOps>(c.getOpcode()), + static_cast<Instruction::BinaryOps>(c.getOpcode()), c.getOperand(0), c.getOperand(1), "", where); } else { switch(c.getOpcode()) { - case Instruction::GetElementPtr: + case Instruction::GetElementPtr: { vector<Value*> idx; for (unsigned i = 1; i < c.getNumOperands(); ++i) @@ -135,7 +135,7 @@ ConstantExpressionsLower::convert(const ConstantExpr& c, Instruction* where) } case Instruction::Cast: - result = new CastInst(c.getOperand(0), c.getType(), "", + result = new CastInst(c.getOperand(0), c.getType(), "", where); break; @@ -143,15 +143,15 @@ ConstantExpressionsLower::convert(const ConstantExpr& c, Instruction* where) case Instruction::Shl: case Instruction::Shr: result = new ShiftInst( - static_cast<Instruction::OtherOps>(c.getOpcode()), + static_cast<Instruction::OtherOps>(c.getOpcode()), c.getOperand(0), c.getOperand(1), "", where); break; - + case Instruction::Select: result = new SelectInst(c.getOperand(0), c.getOperand(1), c.getOperand(2), "", where); break; - + default: std::cerr << "Offending expr: " << c << "\n"; assert(0 && "Constant expression not yet handled!\n"); diff --git a/lib/Transforms/Scalar/LowerGC.cpp b/lib/Transforms/Scalar/LowerGC.cpp index b346334..345fafb 100644 --- a/lib/Transforms/Scalar/LowerGC.cpp +++ b/lib/Transforms/Scalar/LowerGC.cpp @@ -47,7 +47,7 @@ namespace { /// had zero roots. const Type *MainRootRecordType; public: - LowerGC() : GCRootInt(0), GCReadInt(0), GCWriteInt(0), + LowerGC() : GCRootInt(0), GCReadInt(0), GCWriteInt(0), GCRead(0), GCWrite(0), RootChain(0), MainRootRecordType(0) {} virtual bool doInitialization(Module &M); virtual bool runOnFunction(Function &F); @@ -125,7 +125,7 @@ bool LowerGC::doInitialization(Module &M) { if (RootChain == 0) { // If the root chain does not exist, insert a new one with linkonce // linkage! - RootChain = new GlobalVariable(PRLTy, false, + RootChain = new GlobalVariable(PRLTy, false, GlobalValue::LinkOnceLinkage, Constant::getNullValue(PRLTy), "llvm_gc_root_chain", &M); @@ -141,7 +141,7 @@ bool LowerGC::doInitialization(Module &M) { /// not have the specified type, insert a cast. static void Coerce(Instruction *I, unsigned OpNum, Type *Ty) { if (I->getOperand(OpNum)->getType() != Ty) { - if (Constant *C = dyn_cast<Constant>(I->getOperand(OpNum))) + if (Constant *C = dyn_cast<Constant>(I->getOperand(OpNum))) I->setOperand(OpNum, ConstantExpr::getCast(C, Ty)); else { CastInst *CI = new CastInst(I->getOperand(OpNum), Ty, "", I); @@ -152,7 +152,7 @@ static void Coerce(Instruction *I, unsigned OpNum, Type *Ty) { /// runOnFunction - If the program is using GC intrinsics, replace any /// read/write intrinsics with the appropriate read/write barrier calls, then -/// inline them. Finally, build the data structures for +/// inline them. Finally, build the data structures for bool LowerGC::runOnFunction(Function &F) { // Quick exit for programs that are not using GC mechanisms. if (!GCRootInt && !GCReadInt && !GCWriteInt) return false; @@ -192,7 +192,7 @@ bool LowerGC::runOnFunction(Function &F) { CI->setOperand(0, GCRead); } else { // Create a whole new call to replace the old one. - CallInst *NC = new CallInst(GCRead, CI->getOperand(1), + CallInst *NC = new CallInst(GCRead, CI->getOperand(1), CI->getOperand(2), CI->getName(), CI); Value *NV = new CastInst(NC, CI->getType(), "", CI); @@ -208,7 +208,7 @@ bool LowerGC::runOnFunction(Function &F) { MadeChange = true; } } - + // If there are no GC roots in this function, then there is no need to create // a GC list record for it. if (GCRoots.empty()) return MadeChange; @@ -263,7 +263,7 @@ bool LowerGC::runOnFunction(Function &F) { Par[3] = Zero; Value *RootPtrPtr = new GetElementPtrInst(AI, Par, "RootEntPtr", IP); new StoreInst(Null, RootPtrPtr, IP); - + // Each occurrance of the llvm.gcroot intrinsic now turns into an // initialization of the slot with the address and a zeroing out of the // address specified. @@ -301,7 +301,7 @@ bool LowerGC::runOnFunction(Function &F) { UnwindInst *UI = new UnwindInst(Cleanup); PrevPtr = new LoadInst(PrevPtrPtr, "prevptr", UI); new StoreInst(PrevPtr, RootChain, UI); - + // Loop over all of the function calls, turning them into invokes. while (!NormalCalls.empty()) { CallInst *CI = NormalCalls.back(); @@ -314,7 +314,7 @@ bool LowerGC::runOnFunction(Function &F) { // Remove the unconditional branch inserted at the end of the CBB. CBB->getInstList().pop_back(); NewBB->getInstList().remove(CI); - + // Create a new invoke instruction. Value *II = new InvokeInst(CI->getCalledValue(), NewBB, Cleanup, std::vector<Value*>(CI->op_begin()+1, diff --git a/lib/Transforms/Scalar/LowerPacked.cpp b/lib/Transforms/Scalar/LowerPacked.cpp index e224222..725a4ba 100644 --- a/lib/Transforms/Scalar/LowerPacked.cpp +++ b/lib/Transforms/Scalar/LowerPacked.cpp @@ -1,10 +1,10 @@ //===- LowerPacked.cpp - Implementation of LowerPacked Transform ---------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by Brad Jones and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements lowering Packed datatypes into more primitive @@ -38,7 +38,7 @@ namespace { /// class LowerPacked : public FunctionPass, public InstVisitor<LowerPacked> { public: - /// @brief Lowers packed operations to scalar operations. + /// @brief Lowers packed operations to scalar operations. /// @param F The fuction to process virtual bool runOnFunction(Function &F); @@ -60,13 +60,13 @@ public: /// This function asserts if the instruction is a PackedType but /// is handled by another function. - /// + /// /// @brief Asserts if PackedType instruction is not handled elsewhere. /// @param I the unhandled instruction void visitInstruction(Instruction &I) { if(isa<PackedType>(I.getType())) { - std::cerr << "Unhandled Instruction with Packed ReturnType: " << + std::cerr << "Unhandled Instruction with Packed ReturnType: " << I << '\n'; } } @@ -82,7 +82,7 @@ private: void setValues(Value* val,const std::vector<Value*>& values); // Data Members - /// @brief whether we changed the function or not + /// @brief whether we changed the function or not bool Changed; /// @brief a map from old packed values to new smaller packed values @@ -91,27 +91,27 @@ private: /// Instructions in the source program to get rid of /// after we do a pass (the old packed instructions) std::vector<Instruction*> instrsToRemove; -}; +}; -RegisterOpt<LowerPacked> -X("lower-packed", +RegisterOpt<LowerPacked> +X("lower-packed", "lowers packed operations to operations on smaller packed datatypes"); -} // end namespace +} // end namespace FunctionPass *llvm::createLowerPackedPass() { return new LowerPacked(); } // This function sets lowered values for a corresponding // packed value. Note, in the case of a forward reference -// getValues(Value*) will have already been called for -// the packed parameter. This function will then replace -// all references in the in the function of the "dummy" -// value the previous getValues(Value*) call +// getValues(Value*) will have already been called for +// the packed parameter. This function will then replace +// all references in the in the function of the "dummy" +// value the previous getValues(Value*) call // returned with actual references. void LowerPacked::setValues(Value* value,const std::vector<Value*>& values) { - std::map<Value*,std::vector<Value*> >::iterator it = + std::map<Value*,std::vector<Value*> >::iterator it = packedToScalarMap.lower_bound(value); if (it == packedToScalarMap.end() || it->first != value) { // there was not a forward reference to this element @@ -119,7 +119,7 @@ void LowerPacked::setValues(Value* value,const std::vector<Value*>& values) } else { // replace forward declarations with actual definitions - assert(it->second.size() == values.size() && + assert(it->second.size() == values.size() && "Error forward refences and actual definition differ in size"); for (unsigned i = 0, e = values.size(); i != e; ++i) { // replace and get rid of old forward references @@ -133,8 +133,8 @@ void LowerPacked::setValues(Value* value,const std::vector<Value*>& values) // This function will examine the packed value parameter // and if it is a packed constant or a forward reference // properly create the lowered values needed. Otherwise -// it will simply retreive values from a -// setValues(Value*,const std::vector<Value*>&) +// it will simply retreive values from a +// setValues(Value*,const std::vector<Value*>&) // call. Failing both of these cases, it will abort // the program. std::vector<Value*>& LowerPacked::getValues(Value* value) @@ -144,7 +144,7 @@ std::vector<Value*>& LowerPacked::getValues(Value* value) // reject further processing if this one has // already been handled - std::map<Value*,std::vector<Value*> >::iterator it = + std::map<Value*,std::vector<Value*> >::iterator it = packedToScalarMap.lower_bound(value); if (it != packedToScalarMap.end() && it->first == value) { return it->second; @@ -162,11 +162,11 @@ std::vector<Value*>& LowerPacked::getValues(Value* value) } else if (ConstantAggregateZero* CAZ = dyn_cast<ConstantAggregateZero>(value)) { - // zero constant + // zero constant const PackedType* PKT = cast<PackedType>(CAZ->getType()); std::vector<Value*> results; results.reserve(PKT->getNumElements()); - + Constant* C = Constant::getNullValue(PKT->getElementType()); for (unsigned i = 0, e = PKT->getNumElements(); i != e; ++i) { results.push_back(C); @@ -179,7 +179,7 @@ std::vector<Value*>& LowerPacked::getValues(Value* value) const PackedType* PKT = cast<PackedType>(value->getType()); std::vector<Value*> results; results.reserve(PKT->getNumElements()); - + for (unsigned i = 0, e = PKT->getNumElements(); i != e; ++i) { results.push_back(new Argument(PKT->getElementType())); } @@ -221,19 +221,19 @@ void LowerPacked::visitLoadInst(LoadInst& LI) Idx[1] = ConstantUInt::get(Type::UIntTy,i); // Get the pointer - Value* val = new GetElementPtrInst(array, + Value* val = new GetElementPtrInst(array, Idx, - LI.getName() + + LI.getName() + ".ge." + utostr(i), &LI); // generate the new load and save the result in packedToScalar map - values.push_back(new LoadInst(val, + values.push_back(new LoadInst(val, LI.getName()+"."+utostr(i), LI.isVolatile(), &LI)); } - + setValues(&LI,values); Changed = true; instrsToRemove.push_back(&LI); @@ -251,13 +251,13 @@ void LowerPacked::visitBinaryOperator(BinaryOperator& BO) "The two packed operand to scalar maps must be equal in size."); result.reserve(op0Vals.size()); - + // generate the new binary op and save the result for (unsigned i = 0; i != op0Vals.size(); ++i) { - result.push_back(BinaryOperator::create(BO.getOpcode(), - op0Vals[i], + result.push_back(BinaryOperator::create(BO.getOpcode(), + op0Vals[i], op1Vals[i], - BO.getName() + + BO.getName() + "." + utostr(i), &BO)); } @@ -270,12 +270,12 @@ void LowerPacked::visitBinaryOperator(BinaryOperator& BO) void LowerPacked::visitStoreInst(StoreInst& SI) { - if (const PackedType* PKT = + if (const PackedType* PKT = 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); - + ArrayType* AT = ArrayType::get(PKT->getContainedType(0), PKT->getNumElements()); PointerType* APT = PointerType::get(AT); @@ -286,21 +286,21 @@ void LowerPacked::visitStoreInst(StoreInst& SI) "store.ge.a.", &SI); std::vector<Value*>& values = getValues(SI.getOperand(0)); - + assert((values.size() == PKT->getNumElements()) && "Scalar must have the same number of elements as Packed Type"); for (unsigned i = 0, e = PKT->getNumElements(); i != e; ++i) { // Generate the indices for getelementptr Idx[1] = ConstantUInt::get(Type::UIntTy,i); - Value* val = new GetElementPtrInst(array, + Value* val = new GetElementPtrInst(array, Idx, "store.ge." + utostr(i) + ".", &SI); new StoreInst(values[i], val, SI.isVolatile(),&SI); } - + Changed = true; instrsToRemove.push_back(&SI); } @@ -319,12 +319,12 @@ void LowerPacked::visitSelectInst(SelectInst& SELI) for (unsigned i = 0; i != op0Vals.size(); ++i) { result.push_back(new SelectInst(SELI.getCondition(), - op0Vals[i], + op0Vals[i], op1Vals[i], SELI.getName()+ "." + utostr(i), &SELI)); } - + setValues(&SELI,result); Changed = true; instrsToRemove.push_back(&SELI); @@ -334,24 +334,24 @@ void LowerPacked::visitSelectInst(SelectInst& SELI) bool LowerPacked::runOnFunction(Function& F) { // initialize - Changed = false; - + Changed = false; + // Does three passes: - // Pass 1) Converts Packed Operations to + // Pass 1) Converts Packed Operations to // new Packed Operations on smaller // datatypes visit(F); - + // Pass 2) Drop all references std::for_each(instrsToRemove.begin(), instrsToRemove.end(), std::mem_fun(&Instruction::dropAllReferences)); // Pass 3) Delete the Instructions to remove aka packed instructions - for (std::vector<Instruction*>::iterator i = instrsToRemove.begin(), - e = instrsToRemove.end(); + for (std::vector<Instruction*>::iterator i = instrsToRemove.begin(), + e = instrsToRemove.end(); i != e; ++i) { - (*i)->getParent()->getInstList().erase(*i); + (*i)->getParent()->getInstList().erase(*i); } // clean-up diff --git a/lib/Transforms/Scalar/PRE.cpp b/lib/Transforms/Scalar/PRE.cpp index b849331..1ee923a 100644 --- a/lib/Transforms/Scalar/PRE.cpp +++ b/lib/Transforms/Scalar/PRE.cpp @@ -1,10 +1,10 @@ //===- PRE.cpp - Partial Redundancy Elimination ---------------------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements the well-known Partial Redundancy Elimination @@ -80,7 +80,7 @@ namespace { AvailableBlocksTy AvailableBlocks; bool ProcessBlock(BasicBlock *BB); - + // Anticipatibility calculation... void MarkPostDominatingBlocksAnticipatible(PostDominatorTree::Node *N, std::vector<char> &AntBlocks, @@ -262,7 +262,7 @@ void PRE::ReplaceDominatedAvailableOccurrencesWith(Instruction *NewOcc, // active definition... if (ExistingAvailableVal == 0) { ExistingAvailableVal = NewOcc; - + for (DominatorTree::Node::iterator I = N->begin(), E = N->end(); I != E;++I) ReplaceDominatedAvailableOccurrencesWith(NewOcc, *I); } else { @@ -283,7 +283,7 @@ void PRE::ReplaceDominatedAvailableOccurrencesWith(Instruction *NewOcc, for (df_iterator<DominatorTree::Node*> DI = df_begin(N), E = df_end(N); DI != E; ++DI) AvailableBlocks[(*DI)->getBlock()] = NewOcc; - } + } } @@ -400,7 +400,7 @@ bool PRE::ProcessExpression(Instruction *Expr) { if (AnticipatibleBlocks[i]) std::cerr << BlockMapping[i]->getName() <<" "; std::cerr << "\n";); - + // AvailabilityFrontier - Calculates the availability frontier for the current @@ -463,7 +463,7 @@ bool PRE::ProcessExpression(Instruction *Expr) { AnyNotAvailable = true; break; } - + // If any predecessor blocks are not available, add the node to // the current expression dominance frontier. if (AnyNotAvailable) { @@ -597,12 +597,12 @@ bool PRE::ProcessExpression(Instruction *Expr) { ++NumRedundant; DEBUG(std::cerr << " PHI replaces available value: %" << OldVal->getName() << "\n"); - + // Loop over all of the blocks dominated by this PHI node, and change // the AvailableBlocks entries to be the PHI node instead of the old // instruction. MarkOccurrenceAvailableInAllDominatedBlocks(PN, AFBlock); - + AFBlock->getInstList().erase(OldVal); // Delete old instruction! // The resultant PHI node is a new definition of the value! @@ -613,7 +613,7 @@ bool PRE::ProcessExpression(Instruction *Expr) { // region (occurs when hoisting loop invariants, f.e.). In this case, // the PHI node should actually just be removed. assert(PN->use_empty() && "No uses should exist for dead PHI node!"); - PN->getParent()->getInstList().erase(PN); + PN->getParent()->getInstList().erase(PN); } } else { // The resultant PHI node is a new definition of the value! diff --git a/lib/Transforms/Scalar/Reassociate.cpp b/lib/Transforms/Scalar/Reassociate.cpp index 1972b9d..90fcd27 100644 --- a/lib/Transforms/Scalar/Reassociate.cpp +++ b/lib/Transforms/Scalar/Reassociate.cpp @@ -1,10 +1,10 @@ //===- Reassociate.cpp - Reassociate binary expressions -------------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This pass reassociates commutative expressions in an order that is designed @@ -115,7 +115,7 @@ bool Reassociate::ReassociateExpr(BinaryOperator *I) { Value *RHS = I->getOperand(1); unsigned LHSRank = getRank(LHS); unsigned RHSRank = getRank(RHS); - + bool Changed = false; // Make sure the LHS of the operand always has the greater rank... @@ -130,7 +130,7 @@ bool Reassociate::ReassociateExpr(BinaryOperator *I) { DEBUG(std::cerr << "Transposed: " << *I /* << " Result BB: " << I->getParent()*/); } - + // If the LHS is the same operator as the current one is, and if we are the // only expression using it... // @@ -233,7 +233,7 @@ bool Reassociate::ReassociateBB(BasicBlock *BB) { BI = New; New->setOperand(1, NegateValue(New->getOperand(1), BI)); - + Changed = true; DEBUG(std::cerr << "Negated: " << *New /*<< " Result BB: " << BB*/); } diff --git a/lib/Transforms/Scalar/SCCP.cpp b/lib/Transforms/Scalar/SCCP.cpp index 08504f4..384c00d 100644 --- a/lib/Transforms/Scalar/SCCP.cpp +++ b/lib/Transforms/Scalar/SCCP.cpp @@ -1,10 +1,10 @@ //===- SCCP.cpp - Sparse Conditional Constant Propagation -----------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements sparse conditional constant propagation and merging: @@ -45,7 +45,7 @@ using namespace llvm; namespace { class LatticeVal { - enum { + enum { undefined, // This instruction has no known value constant, // This instruction has a constant value overdefined // This instruction has an unknown value @@ -198,7 +198,7 @@ public: private: // markConstant - Make a value be marked as "constant". If the value - // is not already a constant, add it to the instruction work list so that + // is not already a constant, add it to the instruction work list so that // the users of the instruction are updated later. // inline void markConstant(LatticeVal &IV, Value *V, Constant *C) { @@ -212,9 +212,9 @@ private: } // markOverdefined - Make a value be marked as "overdefined". If the - // value is not already overdefined, add it to the overdefined instruction + // value is not already overdefined, add it to the overdefined instruction // work list so that the users of the instruction are updated later. - + inline void markOverdefined(LatticeVal &IV, Value *V) { if (IV.markOverdefined()) { DEBUG(std::cerr << "markOverdefined: "; @@ -262,9 +262,9 @@ private: return ValueState[V]; } - // markEdgeExecutable - Mark a basic block as executable, adding it to the BB + // markEdgeExecutable - Mark a basic block as executable, adding it to the BB // work list if it is not already executable... - // + // void markEdgeExecutable(BasicBlock *Source, BasicBlock *Dest) { if (!KnownFeasibleEdges.insert(Edge(Source, Dest)).second) return; // This edge is already known to be executable! @@ -308,7 +308,7 @@ private: private: friend class InstVisitor<SCCPSolver>; - // visit implementations - Something changed in this instruction... Either an + // visit implementations - Something changed in this instruction... Either an // operand made a transition, or the instruction is newly executable. Change // the value type of I to reflect these changes if appropriate. // @@ -406,7 +406,7 @@ bool SCCPSolver::isEdgeFeasible(BasicBlock *From, BasicBlock *To) { // Make sure the source basic block is executable!! if (!BBExecutable.count(From)) return false; - + // Check to make sure this edge itself is actually feasible now... TerminatorInst *TI = From->getTerminator(); if (BranchInst *BI = dyn_cast<BranchInst>(TI)) { @@ -422,7 +422,7 @@ bool SCCPSolver::isEdgeFeasible(BasicBlock *From, BasicBlock *To) { if (!isa<ConstantBool>(BCValue.getConstant())) return true; // Constant condition variables mean the branch can only go a single way - return BI->getSuccessor(BCValue.getConstant() == + return BI->getSuccessor(BCValue.getConstant() == ConstantBool::False) == To; } return false; @@ -511,7 +511,7 @@ void SCCPSolver::visitPHINode(PHINode &PN) { for (unsigned i = 0, e = PN.getNumIncomingValues(); i != e; ++i) { LatticeVal &IV = getValueState(PN.getIncomingValue(i)); if (IV.isUndefined()) continue; // Doesn't influence PHI node. - + if (isEdgeFeasible(PN.getIncomingBlock(i), PN.getParent())) { if (IV.isOverdefined()) { // PHI node becomes overdefined! markOverdefined(PNIV, &PN); @@ -524,7 +524,7 @@ void SCCPSolver::visitPHINode(PHINode &PN) { // There is already a reachable operand. If we conflict with it, // then the PHI node becomes overdefined. If we agree with it, we // can continue on. - + // Check to see if there are two different constants merging... if (IV.getConstant() != OperandVal) { // Yes there is. This means the PHI node is not constant. @@ -753,7 +753,7 @@ void SCCPSolver::visitGetElementPtrInst(GetElementPtrInst &I) { Constant *Ptr = Operands[0]; Operands.erase(Operands.begin()); // Erase the pointer from idx list... - markConstant(IV, &I, ConstantExpr::getGetElementPtr(Ptr, Operands)); + markConstant(IV, &I, ConstantExpr::getGetElementPtr(Ptr, Operands)); } /// GetGEPGlobalInitializer - Given a constant and a getelementptr constantexpr, @@ -813,7 +813,7 @@ void SCCPSolver::visitLoadInst(LoadInst &I) { markConstant(IV, &I, Constant::getNullValue(I.getType())); return; } - + // Transform load (constant global) into the value loaded. if (GlobalVariable *GV = dyn_cast<GlobalVariable>(Ptr)) { if (GV->isConstant()) { @@ -837,7 +837,7 @@ void SCCPSolver::visitLoadInst(LoadInst &I) { if (CE->getOpcode() == Instruction::GetElementPtr) if (GlobalVariable *GV = dyn_cast<GlobalVariable>(CE->getOperand(0))) if (GV->isConstant() && !GV->isExternal()) - if (Constant *V = + if (Constant *V = GetGEPGlobalInitializer(GV->getInitializer(), CE)) { markConstant(IV, &I, V); return; @@ -857,7 +857,7 @@ void SCCPSolver::visitCallSite(CallSite CS) { hash_map<Function*, LatticeVal>::iterator TFRVI =TrackedFunctionRetVals.end(); if (F && F->hasInternalLinkage()) TFRVI = TrackedFunctionRetVals.find(F); - + if (TFRVI != TrackedFunctionRetVals.end()) { // If this is the first call to the function hit, mark its entry block // executable. @@ -883,7 +883,7 @@ void SCCPSolver::visitCallSite(CallSite CS) { mergeInValue(IV, I, TFRVI->second); return; } - + if (F == 0 || !F->isExternal() || !canConstantFoldCallTo(F)) { markOverdefined(IV, I); return; @@ -914,7 +914,7 @@ void SCCPSolver::visitCallSite(CallSite CS) { void SCCPSolver::Solve() { // Process the work lists until they are empty! - while (!BBWorkList.empty() || !InstWorkList.empty() || + while (!BBWorkList.empty() || !InstWorkList.empty() || !OverdefinedInstWorkList.empty()) { // Process the instruction work list... while (!OverdefinedInstWorkList.empty()) { @@ -922,7 +922,7 @@ void SCCPSolver::Solve() { OverdefinedInstWorkList.pop_back(); DEBUG(std::cerr << "\nPopped off OI-WL: " << *I); - + // "I" got into the work list because it either made the transition from // bottom to constant // @@ -940,7 +940,7 @@ void SCCPSolver::Solve() { InstWorkList.pop_back(); DEBUG(std::cerr << "\nPopped off I-WL: " << *I); - + // "I" got into the work list because it either made the transition from // bottom to constant // @@ -953,14 +953,14 @@ void SCCPSolver::Solve() { UI != E; ++UI) OperandChangedState(*UI); } - + // Process the basic block work list... while (!BBWorkList.empty()) { BasicBlock *BB = BBWorkList.back(); BBWorkList.pop_back(); - + DEBUG(std::cerr << "\nPopped off BBWL: " << *BB); - + // Notify all instructions in this basic block that they are newly // executable. visit(BB); @@ -1016,7 +1016,7 @@ namespace { // algorithm, and return true if the function was modified. // bool runOnFunction(Function &F); - + virtual void getAnalysisUsage(AnalysisUsage &AU) const { AU.setPreservesCFG(); } @@ -1095,13 +1095,13 @@ bool SCCP::runOnFunction(Function &F) { Constant *Const = IV.isConstant() ? IV.getConstant() : UndefValue::get(Inst->getType()); DEBUG(std::cerr << " Constant: " << *Const << " = " << *Inst); - + // Replaces all of the uses of a variable with uses of the constant. Inst->replaceAllUsesWith(Const); - + // Delete the instruction. BB->getInstList().erase(Inst); - + // Hey, we just changed something! MadeChanges = true; ++NumInstRemoved; @@ -1217,7 +1217,7 @@ bool IPSCCP::runOnModule(Module &M) { Constant *CST = IV.isConstant() ? IV.getConstant() : UndefValue::get(AI->getType()); DEBUG(std::cerr << "*** Arg " << *AI << " = " << *CST <<"\n"); - + // Replaces all of the uses of a variable with uses of the // constant. AI->replaceAllUsesWith(CST); @@ -1247,7 +1247,7 @@ bool IPSCCP::runOnModule(Module &M) { MadeChanges = true; ++IPNumInstRemoved; } - + for (unsigned i = 0, e = TI->getNumSuccessors(); i != e; ++i) { BasicBlock *Succ = TI->getSuccessor(i); if (Succ->begin() != Succ->end() && isa<PHINode>(Succ->begin())) @@ -1272,11 +1272,11 @@ bool IPSCCP::runOnModule(Module &M) { Constant *Const = IV.isConstant() ? IV.getConstant() : UndefValue::get(Inst->getType()); DEBUG(std::cerr << " Constant: " << *Const << " = " << *Inst); - + // Replaces all of the uses of a variable with uses of the // constant. Inst->replaceAllUsesWith(Const); - + // Delete the instruction. if (!isa<TerminatorInst>(Inst) && !isa<CallInst>(Inst)) BB->getInstList().erase(Inst); @@ -1300,7 +1300,7 @@ bool IPSCCP::runOnModule(Module &M) { bool Folded = ConstantFoldTerminator(I->getParent()); assert(Folded && "Didn't fold away reference to block!"); } - + // Finally, delete the basic block. F->getBasicBlockList().erase(DeadBB); } @@ -1338,6 +1338,6 @@ bool IPSCCP::runOnModule(Module &M) { M.getGlobalList().erase(GV); ++IPNumGlobalConst; } - + return MadeChanges; } diff --git a/lib/Transforms/Scalar/ScalarReplAggregates.cpp b/lib/Transforms/Scalar/ScalarReplAggregates.cpp index f934f1f..4a6aee3 100644 --- a/lib/Transforms/Scalar/ScalarReplAggregates.cpp +++ b/lib/Transforms/Scalar/ScalarReplAggregates.cpp @@ -1,10 +1,10 @@ //===- ScalarReplAggregates.cpp - Scalar Replacement of Aggregates --------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This transformation implements the well known scalar replacement of @@ -91,7 +91,7 @@ bool SROA::performPromotion(Function &F) { BasicBlock &BB = F.getEntryBlock(); // Get the entry node for the function bool Changed = false; - + while (1) { Allocas.clear(); @@ -154,7 +154,7 @@ bool SROA::performScalarRepl(Function &F) { DEBUG(std::cerr << "Found inst to xform: " << *AI); Changed = true; - + std::vector<AllocaInst*> ElementAllocas; if (const StructType *ST = dyn_cast<StructType>(AI->getAllocatedType())) { ElementAllocas.reserve(ST->getNumContainedTypes()); @@ -175,7 +175,7 @@ bool SROA::performScalarRepl(Function &F) { WorkList.push_back(NA); // Add to worklist for recursive processing } } - + // Now that we have created the alloca instructions that we want to use, // expand the getelementptr instructions to use them. // @@ -183,12 +183,12 @@ bool SROA::performScalarRepl(Function &F) { Instruction *User = cast<Instruction>(AI->use_back()); GetElementPtrInst *GEPI = cast<GetElementPtrInst>(User); // We now know that the GEP is of the form: GEP <ptr>, 0, <cst> - unsigned Idx = + unsigned Idx = (unsigned)cast<ConstantInt>(GEPI->getOperand(2))->getRawValue(); - + assert(Idx < ElementAllocas.size() && "Index out of range?"); AllocaInst *AllocaToUse = ElementAllocas[Idx]; - + Value *RepValue; if (GEPI->getNumOperands() == 3) { // Do not insert a new getelementptr instruction with zero indices, only @@ -206,7 +206,7 @@ bool SROA::performScalarRepl(Function &F) { GEPI->setName(""); RepValue = new GetElementPtrInst(AllocaToUse, NewArgs, OldName, GEPI); } - + // Move all of the users over to the new GEP. GEPI->replaceAllUsesWith(RepValue); // Delete the old GEP @@ -259,7 +259,7 @@ static bool AllUsersAreLoads(Value *Ptr) { I != E; ++I) if (cast<Instruction>(*I)->getOpcode() != Instruction::Load) return false; - return true; + return true; } /// isSafeUseOfAllocation - Check to see if this user is an allowed use for an @@ -289,7 +289,7 @@ int SROA::isSafeUseOfAllocation(Instruction *User) { // if (cast<ConstantInt>(GEPI->getOperand(2))->getRawValue() >= NumElements) return 0; - + } else { // If this is an array index and the index is not constant, we cannot // promote... that is unless the array has exactly one or two elements in @@ -342,7 +342,7 @@ void SROA::CanonicalizeAllocaUsers(AllocationInst *AI) { if (const ArrayType *AT = dyn_cast<ArrayType>(*I)) { uint64_t NumElements = AT->getNumElements(); - + if (!isa<ConstantInt>(I.getOperand())) { if (NumElements == 1) { GEPI->setOperand(2, Constant::getNullValue(Type::IntTy)); diff --git a/lib/Transforms/Scalar/SimplifyCFG.cpp b/lib/Transforms/Scalar/SimplifyCFG.cpp index 88b625b..8b9c518 100644 --- a/lib/Transforms/Scalar/SimplifyCFG.cpp +++ b/lib/Transforms/Scalar/SimplifyCFG.cpp @@ -1,10 +1,10 @@ //===- SimplifyCFG.cpp - CFG Simplification Pass --------------------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements dead code elimination and basic block merging. @@ -100,7 +100,7 @@ bool CFGSimplifyPass::runOnFunction(Function &F) { (*SI)->removePredecessor(BB); BB->dropAllReferences(); } - + for (Function::iterator I = ++F.begin(); I != F.end();) if (!Reachable.count(I)) I = F.getBasicBlockList().erase(I); diff --git a/lib/Transforms/Scalar/TailDuplication.cpp b/lib/Transforms/Scalar/TailDuplication.cpp index 0a05d0f..f78ce91 100644 --- a/lib/Transforms/Scalar/TailDuplication.cpp +++ b/lib/Transforms/Scalar/TailDuplication.cpp @@ -1,10 +1,10 @@ //===- TailDuplication.cpp - Simplify CFG through tail duplication --------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This pass performs a limited form of tail duplication, intended to simplify @@ -127,7 +127,7 @@ bool TailDup::shouldEliminateUnconditionalBranch(TerminatorInst *TI) { if (TooMany-- == 0) return false; } - return true; + return true; } /// FindObviousSharedDomOf - We know there is a branch from SrcBlock to @@ -141,7 +141,7 @@ static BasicBlock *FindObviousSharedDomOf(BasicBlock *SrcBlock, if (PI == PE || ++PI != PE) return 0; BasicBlock *SrcPred = *pred_begin(SrcBlock); - + // Look at the predecessors of DstBlock. One of them will be SrcBlock. If // there is only one other pred, get it, otherwise we can't handle it. PI = pred_begin(DstBlock); PE = pred_end(DstBlock); @@ -199,7 +199,7 @@ void TailDup::eliminateUnconditionalBranch(BranchInst *Branch) { while (isa<PHINode>(BBI)) ++BBI; while (!isa<TerminatorInst>(BBI)) { Instruction *I = BBI++; - + bool CanHoist = !I->isTrapping() && !I->mayWriteToMemory(); if (CanHoist) { for (unsigned op = 0, e = I->getNumOperands(); op != e; ++op) @@ -303,7 +303,7 @@ void TailDup::eliminateUnconditionalBranch(BranchInst *Branch) { // Ok, we have a PHI node. Figure out what the incoming value was for the // DestBlock. Value *IV = PN->getIncomingValueForBlock(DestBlock); - + // Remap the value if necessary... if (Value *MappedIV = ValueMapping[IV]) IV = MappedIV; diff --git a/lib/Transforms/Scalar/TailRecursionElimination.cpp b/lib/Transforms/Scalar/TailRecursionElimination.cpp index bf098eb..ed8e546 100644 --- a/lib/Transforms/Scalar/TailRecursionElimination.cpp +++ b/lib/Transforms/Scalar/TailRecursionElimination.cpp @@ -1,10 +1,10 @@ //===- TailRecursionElimination.cpp - Eliminate Tail Calls ----------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file transforms calls of the current function (self recursion) followed @@ -89,7 +89,7 @@ bool TailCallElim::runOnFunction(Function &F) { for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) if (ReturnInst *Ret = dyn_cast<ReturnInst>(BB->getTerminator())) MadeChange |= ProcessReturningBlock(Ret, OldEntry, ArgumentPHIs); - + // If we eliminated any tail recursions, it's possible that we inserted some // silly PHI nodes which just merge an initial value (the incoming operand) // with themselves. Check to see if we did and clean up our mess if so. This @@ -163,7 +163,7 @@ static bool isDynamicConstant(Value *V, CallInst *CI) { Function *F = CI->getParent()->getParent(); for (Function::arg_iterator AI = F->arg_begin(); &*AI != Arg; ++AI) ++ArgNo; - + // If we are passing this argument into call as the corresponding // argument operand, then the argument is dynamically constant. // Otherwise, we cannot transform this function safely. @@ -292,7 +292,7 @@ bool TailCallElim::ProcessReturningBlock(ReturnInst *Ret, BasicBlock *&OldEntry, std::string OldName = OldEntry->getName(); OldEntry->setName("tailrecurse"); BasicBlock *NewEntry = new BasicBlock(OldName, F, OldEntry); new BranchInst(OldEntry, NewEntry); - + // Now that we have created a new block, which jumps to the entry // block, insert a PHI node for each argument of the function. // For now, we initialize each PHI to only have the real arguments @@ -305,13 +305,13 @@ bool TailCallElim::ProcessReturningBlock(ReturnInst *Ret, BasicBlock *&OldEntry, ArgumentPHIs.push_back(PN); } } - + // Ok, now that we know we have a pseudo-entry block WITH all of the // required PHI nodes, add entries into the PHI node for the actual // parameters passed into the tail-recursive call. for (unsigned i = 0, e = CI->getNumOperands()-1; i != e; ++i) ArgumentPHIs[i]->addIncoming(CI->getOperand(i+1), BB); - + // If we are introducing an accumulator variable to eliminate the recursion, // do so now. Note that we _know_ that no subsequent tail recursion // eliminations will happen on this function because of the way the diff --git a/lib/Transforms/TransformInternals.cpp b/lib/Transforms/TransformInternals.cpp index 7aca672..4f2dcdf 100644 --- a/lib/Transforms/TransformInternals.cpp +++ b/lib/Transforms/TransformInternals.cpp @@ -1,10 +1,10 @@ //===- TransformInternals.cpp - Implement shared functions for transforms -===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file defines shared functions used by the different components of the @@ -30,10 +30,10 @@ static const Type *getStructOffsetStep(const StructType *STy, uint64_t &Offset, for (i = 0; i < SL->MemberOffsets.size()-1; ++i) if (Offset >= SL->MemberOffsets[i] && Offset < SL->MemberOffsets[i+1]) break; - + assert(Offset >= SL->MemberOffsets[i] && (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)); Offset = SL->MemberOffsets[i]; diff --git a/lib/Transforms/TransformInternals.h b/lib/Transforms/TransformInternals.h index 9b90fcc..ba3bd5a 100644 --- a/lib/Transforms/TransformInternals.h +++ b/lib/Transforms/TransformInternals.h @@ -1,10 +1,10 @@ //===-- TransformInternals.h - Shared functions for Transforms --*- C++ -*-===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This header file declares shared functions used by the different components @@ -56,7 +56,7 @@ const Type *ConvertibleToGEP(const Type *Ty, Value *V, // ValueHandle Class - Smart pointer that occupies a slot on the users USE list // that prevents it from being destroyed. This "looks" like an Instruction // with Opcode UserOp1. -// +// class ValueMapCache; class ValueHandle : public Instruction { Use Op; diff --git a/lib/Transforms/Utils/BasicBlockUtils.cpp b/lib/Transforms/Utils/BasicBlockUtils.cpp index efaf22d..f344580 100644 --- a/lib/Transforms/Utils/BasicBlockUtils.cpp +++ b/lib/Transforms/Utils/BasicBlockUtils.cpp @@ -1,10 +1,10 @@ //===-- BasicBlockUtils.cpp - BasicBlock Utilities -------------------------==// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This family of functions perform manipulations on basic blocks, and @@ -30,7 +30,7 @@ void llvm::ReplaceInstWithValue(BasicBlock::InstListType &BIL, I.replaceAllUsesWith(V); std::string OldName = I.getName(); - + // Delete the unnecessary instruction now... BI = BIL.erase(BI); @@ -92,7 +92,7 @@ void llvm::RemoveSuccessor(TerminatorInst *TI, unsigned SuccNum) { cast<BranchInst>(TI)->setUnconditionalDest(TI->getSuccessor(1-SuccNum)); } else { // Otherwise convert to a return instruction... Value *RetVal = 0; - + // Create a value to return... if the function doesn't return null... if (BB->getParent()->getReturnType() != Type::VoidTy) RetVal = Constant::getNullValue(BB->getParent()->getReturnType()); @@ -100,7 +100,7 @@ void llvm::RemoveSuccessor(TerminatorInst *TI, unsigned SuccNum) { // Create the return... NewTI = new ReturnInst(RetVal); } - break; + break; case Instruction::Invoke: // Should convert to call case Instruction::Switch: // Should remove entry diff --git a/lib/Transforms/Utils/BreakCriticalEdges.cpp b/lib/Transforms/Utils/BreakCriticalEdges.cpp index 87b019f..acc1e2c 100644 --- a/lib/Transforms/Utils/BreakCriticalEdges.cpp +++ b/lib/Transforms/Utils/BreakCriticalEdges.cpp @@ -1,10 +1,10 @@ //===- BreakCriticalEdges.cpp - Critical Edge Elimination Pass ------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // BreakCriticalEdges pass - Break all of the critical edges in the CFG by @@ -31,7 +31,7 @@ namespace { struct BreakCriticalEdges : public FunctionPass { virtual bool runOnFunction(Function &F); - + virtual void getAnalysisUsage(AnalysisUsage &AU) const { AU.addPreserved<DominatorSet>(); AU.addPreserved<ImmediateDominators>(); @@ -108,7 +108,7 @@ bool llvm::SplitCriticalEdge(TerminatorInst *TI, unsigned SuccNum, Pass *P) { DestBB->getName() + "_crit_edge"); // Create our unconditional branch... new BranchInst(DestBB, NewBB); - + // Branch to the new block, breaking the edge... TI->setSuccessor(SuccNum, NewBB); @@ -150,11 +150,11 @@ bool llvm::SplitCriticalEdge(TerminatorInst *TI, unsigned SuccNum, Pass *P) { // anything. ID->addNewBlock(NewBB, TIBB); } - + // Should we update DominatorTree information? if (DominatorTree *DT = P->getAnalysisToUpdate<DominatorTree>()) { DominatorTree::Node *TINode = DT->getNode(TIBB); - + // The new block is not the immediate dominator for any other nodes, but // TINode is the immediate dominator for the new node. // diff --git a/lib/Transforms/Utils/CloneFunction.cpp b/lib/Transforms/Utils/CloneFunction.cpp index 6440851..7eaf147 100644 --- a/lib/Transforms/Utils/CloneFunction.cpp +++ b/lib/Transforms/Utils/CloneFunction.cpp @@ -1,10 +1,10 @@ //===- CloneFunction.cpp - Clone a function into another function ---------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements the CloneFunctionInto interface, which is used as the @@ -47,7 +47,7 @@ void llvm::CloneFunctionInto(Function *NewFunc, const Function *OldFunc, std::vector<ReturnInst*> &Returns, const char *NameSuffix) { assert(NameSuffix && "NameSuffix cannot be null!"); - + #ifndef NDEBUG for (Function::const_arg_iterator I = OldFunc->arg_begin(), E = OldFunc->arg_end(); I != E; ++I) @@ -61,7 +61,7 @@ void llvm::CloneFunctionInto(Function *NewFunc, const Function *OldFunc, for (Function::const_iterator BI = OldFunc->begin(), BE = OldFunc->end(); BI != BE; ++BI) { const BasicBlock &BB = *BI; - + // Create a new basic block and copy instructions into it! BasicBlock *CBB = CloneBasicBlock(&BB, ValueMap, NameSuffix, NewFunc); ValueMap[&BB] = CBB; // Add basic block mapping. @@ -70,7 +70,7 @@ void llvm::CloneFunctionInto(Function *NewFunc, const Function *OldFunc, Returns.push_back(RI); } - // Loop over all of the instructions in the function, fixing up operand + // Loop over all of the instructions in the function, fixing up operand // references as we go. This uses ValueMap to do all the hard work. // for (Function::iterator BB = cast<BasicBlock>(ValueMap[OldFunc->begin()]), @@ -105,7 +105,7 @@ Function *llvm::CloneFunction(const Function *F, // Create the new function... Function *NewF = new Function(FTy, F->getLinkage(), F->getName()); - + // Loop over the arguments, copying the names of the mapped arguments over... Function::arg_iterator DestI = NewF->arg_begin(); for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I) @@ -116,6 +116,6 @@ Function *llvm::CloneFunction(const Function *F, std::vector<ReturnInst*> Returns; // Ignore returns cloned... CloneFunctionInto(NewF, F, ValueMap, Returns); - return NewF; + return NewF; } diff --git a/lib/Transforms/Utils/CloneModule.cpp b/lib/Transforms/Utils/CloneModule.cpp index 66e005e..fd24287 100644 --- a/lib/Transforms/Utils/CloneModule.cpp +++ b/lib/Transforms/Utils/CloneModule.cpp @@ -1,10 +1,10 @@ //===- CloneModule.cpp - Clone an entire module ---------------------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements the CloneModule interface which makes a copy of an diff --git a/lib/Transforms/Utils/CloneTrace.cpp b/lib/Transforms/Utils/CloneTrace.cpp index 52bdd15..5eca653 100644 --- a/lib/Transforms/Utils/CloneTrace.cpp +++ b/lib/Transforms/Utils/CloneTrace.cpp @@ -1,10 +1,10 @@ //===- CloneTrace.cpp - Clone a trace -------------------------------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements the CloneTrace interface, which is used when writing @@ -27,7 +27,7 @@ std::vector<BasicBlock *> llvm::CloneTrace(const std::vector<BasicBlock*> &origTrace) { std::vector<BasicBlock *> clonedTrace; std::map<const Value*, Value*> ValueMap; - + //First, loop over all the Basic Blocks in the trace and copy //them using CloneBasicBlock. Also fix the phi nodes during //this loop. To fix the phi nodes, we delete incoming branches @@ -38,7 +38,7 @@ llvm::CloneTrace(const std::vector<BasicBlock*> &origTrace) { //Clone Basic Block BasicBlock *clonedBlock = CloneBasicBlock(*T, ValueMap, ".tr", (*T)->getParent()); - + //Add it to our new trace clonedTrace.push_back(clonedBlock); @@ -55,10 +55,10 @@ llvm::CloneTrace(const std::vector<BasicBlock*> &origTrace) { //get incoming value for the previous BB Value *V = PN->getIncomingValueForBlock(*(T-1)); assert(V && "No incoming value from a BasicBlock in our trace!"); - + //remap our phi node to point to incoming value ValueMap[*&I] = V; - + //remove phi node clonedBlock->getInstList().erase(PN); } @@ -69,7 +69,7 @@ llvm::CloneTrace(const std::vector<BasicBlock*> &origTrace) { for(std::vector<BasicBlock *>::const_iterator BB = clonedTrace.begin(), BE = clonedTrace.end(); BB != BE; ++BB) { for(BasicBlock::iterator I = (*BB)->begin(); I != (*BB)->end(); ++I) { - + //Loop over all the operands of the instruction for(unsigned op=0, E = I->getNumOperands(); op != E; ++op) { const Value *Op = I->getOperand(op); @@ -83,7 +83,7 @@ llvm::CloneTrace(const std::vector<BasicBlock*> &origTrace) { } } } - + //return new vector of basic blocks return clonedTrace; } diff --git a/lib/Transforms/Utils/CodeExtractor.cpp b/lib/Transforms/Utils/CodeExtractor.cpp index cf9cafb0..85b9dcb 100644 --- a/lib/Transforms/Utils/CodeExtractor.cpp +++ b/lib/Transforms/Utils/CodeExtractor.cpp @@ -1,10 +1,10 @@ //===- CodeExtractor.cpp - Pull code region into a new function -----------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements the interface to tear out a code region, such as an @@ -64,7 +64,7 @@ namespace { return true; return false; } - + /// definedInCaller - Return true if the specified value is defined in the /// function being code extracted, but not in the region being extracted. /// These values must be passed in as live-ins to the function. @@ -198,7 +198,7 @@ void CodeExtractor::splitReturnBlocks() { // void CodeExtractor::findInputsOutputs(Values &inputs, Values &outputs) { std::set<BasicBlock*> ExitBlocks; - for (std::set<BasicBlock*>::const_iterator ci = BlocksToExtract.begin(), + for (std::set<BasicBlock*>::const_iterator ci = BlocksToExtract.begin(), ce = BlocksToExtract.end(); ci != ce; ++ci) { BasicBlock *BB = *ci; @@ -208,7 +208,7 @@ void CodeExtractor::findInputsOutputs(Values &inputs, Values &outputs) { for (User::op_iterator O = I->op_begin(), E = I->op_end(); O != E; ++O) if (definedInCaller(*O)) inputs.push_back(*O); - + // Consider uses of this instruction (outputs). for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); UI != E; ++UI) @@ -326,7 +326,7 @@ Function *CodeExtractor::constructFunction(const Values &inputs, for (unsigned i = 0, e = inputs.size(); i != e; ++i, ++AI) AI->setName(inputs[i]->getName()); for (unsigned i = 0, e = outputs.size(); i != e; ++i, ++AI) - AI->setName(outputs[i]->getName()+".out"); + AI->setName(outputs[i]->getName()+".out"); } // Rewrite branches to basic blocks outside of the loop to new dummy blocks @@ -383,8 +383,8 @@ emitCallAndSwitchStatement(Function *newFunction, BasicBlock *codeReplacer, // Allocate a struct at the beginning of this function Type *StructArgTy = StructType::get(ArgTypes); - Struct = - new AllocaInst(StructArgTy, 0, "structArg", + Struct = + new AllocaInst(StructArgTy, 0, "structArg", codeReplacer->getParent()->begin()->begin()); params.push_back(Struct); @@ -399,7 +399,7 @@ emitCallAndSwitchStatement(Function *newFunction, BasicBlock *codeReplacer, StoreInst *SI = new StoreInst(StructValues[i], GEP); codeReplacer->getInstList().push_back(SI); } - } + } // Emit the call to the function CallInst *call = new CallInst(newFunction, params, @@ -418,7 +418,7 @@ emitCallAndSwitchStatement(Function *newFunction, BasicBlock *codeReplacer, std::vector<Value*> Indices; Indices.push_back(Constant::getNullValue(Type::UIntTy)); Indices.push_back(ConstantUInt::get(Type::UIntTy, FirstOut + i)); - GetElementPtrInst *GEP + GetElementPtrInst *GEP = new GetElementPtrInst(Struct, Indices, "gep_reload_" + outputs[i]->getName()); codeReplacer->getInstList().push_back(GEP); @@ -521,7 +521,7 @@ emitCallAndSwitchStatement(Function *newFunction, BasicBlock *codeReplacer, Indices.push_back(ConstantUInt::get(Type::UIntTy,FirstOut+out)); GetElementPtrInst *GEP = new GetElementPtrInst(OAI, Indices, - "gep_" + outputs[out]->getName(), + "gep_" + outputs[out]->getName(), NTRet); new StoreInst(outputs[out], GEP, NTRet); } else { @@ -545,7 +545,7 @@ emitCallAndSwitchStatement(Function *newFunction, BasicBlock *codeReplacer, // There are no successors (the block containing the switch itself), which // means that previously this was the last part of the function, and hence // this should be rewritten as a `ret' - + // Check if the function should return a value if (OldFnRetTy == Type::VoidTy) { new ReturnInst(0, TheSwitch); // Return void @@ -603,13 +603,13 @@ void CodeExtractor::moveCodeToFunction(Function *newFunction) { /// /// find inputs and outputs for the region /// -/// for inputs: add to function as args, map input instr* to arg# -/// for outputs: add allocas for scalars, +/// for inputs: add to function as args, map input instr* to arg# +/// for outputs: add allocas for scalars, /// add to func as args, map output instr* to arg# /// /// rewrite func to use argument #s instead of instr* /// -/// for each scalar output in the function: at every exit, store intermediate +/// for each scalar output in the function: at every exit, store intermediate /// computed result back into memory. /// Function *CodeExtractor:: @@ -637,7 +637,7 @@ ExtractCodeRegion(const std::vector<BasicBlock*> &code) { assert(BlocksToExtract.count(*PI) && "No blocks in this region may have entries from outside the region" " except for the first block!"); - + // If we have to split PHI nodes or the entry block, do so now. severSplitPHINodes(header); @@ -660,7 +660,7 @@ ExtractCodeRegion(const std::vector<BasicBlock*> &code) { // Construct new function based on inputs/outputs & add allocas for all defs. Function *newFunction = constructFunction(inputs, outputs, header, - newFuncRoot, + newFuncRoot, codeReplacer, oldFunction, oldFunction->getParent()); @@ -676,7 +676,7 @@ ExtractCodeRegion(const std::vector<BasicBlock*> &code) { if (!BlocksToExtract.count(PN->getIncomingBlock(i))) PN->setIncomingBlock(i, newFuncRoot); } - + // Look at all successors of the codeReplacer block. If any of these blocks // had PHI nodes in them, we need to update the "from" block to be the code // replacer, not the original block in the extracted region. @@ -697,7 +697,7 @@ ExtractCodeRegion(const std::vector<BasicBlock*> &code) { --i; --e; } } - + //std::cerr << "NEW FUNCTION: " << *newFunction; // verifyFunction(*newFunction); @@ -744,5 +744,5 @@ Function* llvm::ExtractLoop(DominatorSet &DS, Loop *L, bool AggregateArgs) { Function* llvm::ExtractBasicBlock(BasicBlock *BB, bool AggregateArgs) { std::vector<BasicBlock*> Blocks; Blocks.push_back(BB); - return CodeExtractor(0, AggregateArgs).ExtractCodeRegion(Blocks); + return CodeExtractor(0, AggregateArgs).ExtractCodeRegion(Blocks); } diff --git a/lib/Transforms/Utils/DemoteRegToStack.cpp b/lib/Transforms/Utils/DemoteRegToStack.cpp index 74d618c..ecd92f7 100644 --- a/lib/Transforms/Utils/DemoteRegToStack.cpp +++ b/lib/Transforms/Utils/DemoteRegToStack.cpp @@ -1,12 +1,12 @@ //===- DemoteRegToStack.cpp - Move a virtual register to the stack --------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// -// +// // This file provide the function DemoteRegToStack(). This function takes a // virtual register computed by an Instruction and replaces it with a slot in // the stack frame, allocated via alloca. It returns the pointer to the diff --git a/lib/Transforms/Utils/InlineFunction.cpp b/lib/Transforms/Utils/InlineFunction.cpp index 6bfdda2..97ee58f 100644 --- a/lib/Transforms/Utils/InlineFunction.cpp +++ b/lib/Transforms/Utils/InlineFunction.cpp @@ -1,10 +1,10 @@ //===- InlineFunction.cpp - Code to perform function inlining -------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements inlining of a function into a call site, resolving @@ -31,8 +31,8 @@ bool llvm::InlineFunction(InvokeInst *II) {return InlineFunction(CallSite(II));} // block of the caller. This returns false if it is not possible to inline this // call. The program is still in a well defined state if this occurs though. // -// Note that this only does one level of inlining. For example, if the -// instruction 'call B' is inlined, and 'B' calls 'C', then the call to 'C' now +// Note that this only does one level of inlining. For example, if the +// instruction 'call B' is inlined, and 'B' calls 'C', then the call to 'C' now // exists in the instruction stream. Similiarly this will inline a recursive // function by one level. // @@ -60,18 +60,18 @@ bool llvm::InlineFunction(CallSite CS) { { // Scope to destroy ValueMap after cloning. // Calculate the vector of arguments to pass into the function cloner... std::map<const Value*, Value*> ValueMap; - assert(std::distance(CalledFunc->arg_begin(), CalledFunc->arg_end()) == + assert(std::distance(CalledFunc->arg_begin(), CalledFunc->arg_end()) == std::distance(CS.arg_begin(), CS.arg_end()) && "No varargs calls can be inlined!"); - + CallSite::arg_iterator AI = CS.arg_begin(); for (Function::const_arg_iterator I = CalledFunc->arg_begin(), E = CalledFunc->arg_end(); I != E; ++I, ++AI) ValueMap[I] = *AI; - - // Clone the entire body of the callee into the caller. + + // Clone the entire body of the callee into the caller. CloneFunctionInto(Caller, CalledFunc, ValueMap, Returns, ".i"); - } + } // Remember the first block that is newly cloned over. Function::iterator FirstNewBlock = LastBlock; ++FirstNewBlock; @@ -131,21 +131,21 @@ bool llvm::InlineFunction(CallSite CS) { } else { // First, split the basic block... BasicBlock *Split = BB->splitBasicBlock(CI, CI->getName()+".noexc"); - + // Next, create the new invoke instruction, inserting it at the end // of the old basic block. InvokeInst *II = - new InvokeInst(CI->getCalledValue(), Split, InvokeDest, + new InvokeInst(CI->getCalledValue(), Split, InvokeDest, std::vector<Value*>(CI->op_begin()+1, CI->op_end()), CI->getName(), BB->getTerminator()); // Make sure that anything using the call now uses the invoke! CI->replaceAllUsesWith(II); - + // Delete the unconditional branch inserted by splitBasicBlock BB->getInstList().pop_back(); Split->getInstList().pop_front(); // Delete the original call - + // Update any PHI nodes in the exceptional block to indicate that // there is now a new entry in them. unsigned i = 0; @@ -154,7 +154,7 @@ bool llvm::InlineFunction(CallSite CS) { PHINode *PN = cast<PHINode>(I); PN->addIncoming(InvokeDestPHIValues[i], BB); } - + // This basic block is now complete, start scanning the next one. break; } @@ -200,7 +200,7 @@ bool llvm::InlineFunction(CallSite CS) { FirstNewBlock->begin(), FirstNewBlock->end()); // Remove the cloned basic block. Caller->getBasicBlockList().pop_back(); - + // If the call site was an invoke instruction, add a branch to the normal // destination. if (InvokeInst *II = dyn_cast<InvokeInst>(TheCall)) @@ -229,16 +229,16 @@ bool llvm::InlineFunction(CallSite CS) { // this is an invoke instruction or a call instruction. BasicBlock *AfterCallBB; if (InvokeInst *II = dyn_cast<InvokeInst>(TheCall)) { - + // Add an unconditional branch to make this look like the CallInst case... BranchInst *NewBr = new BranchInst(II->getNormalDest(), TheCall); - + // Split the basic block. This guarantees that no PHI nodes will have to be // updated due to new incoming edges, and make the invoke case more // symmetric to the call case. AfterCallBB = OrigBB->splitBasicBlock(NewBr, CalledFunc->getName()+".exit"); - + } else { // It's a call // If this is a call instruction, we need to split the basic block that // the call lives in. @@ -251,7 +251,7 @@ bool llvm::InlineFunction(CallSite CS) { // basic block of the inlined function. // TerminatorInst *Br = OrigBB->getTerminator(); - assert(Br && Br->getOpcode() == Instruction::Br && + assert(Br && Br->getOpcode() == Instruction::Br && "splitBasicBlock broken!"); Br->setOperand(0, FirstNewBlock); @@ -273,39 +273,39 @@ bool llvm::InlineFunction(CallSite CS) { if (!TheCall->use_empty()) { PHI = new PHINode(CalledFunc->getReturnType(), TheCall->getName(), AfterCallBB->begin()); - + // Anything that used the result of the function call should now use the // PHI node as their operand. // TheCall->replaceAllUsesWith(PHI); } - + // Loop over all of the return instructions, turning them into unconditional // branches to the merge point now, and adding entries to the PHI node as // appropriate. for (unsigned i = 0, e = Returns.size(); i != e; ++i) { ReturnInst *RI = Returns[i]; - + if (PHI) { assert(RI->getReturnValue() && "Ret should have value!"); - assert(RI->getReturnValue()->getType() == PHI->getType() && + assert(RI->getReturnValue()->getType() == PHI->getType() && "Ret value not consistent in function!"); PHI->addIncoming(RI->getReturnValue(), RI->getParent()); } - + // Add a branch to the merge point where the PHI node lives if it exists. new BranchInst(AfterCallBB, RI); - + // Delete the return instruction now RI->getParent()->getInstList().erase(RI); } - + } else if (!Returns.empty()) { // Otherwise, if there is exactly one return value, just replace anything // using the return value of the call with the computed value. if (!TheCall->use_empty()) TheCall->replaceAllUsesWith(Returns[0]->getReturnValue()); - + // Splice the code from the return block into the block that it will return // to, which contains the code that was after the call. BasicBlock *ReturnBB = Returns[0]->getParent(); @@ -314,7 +314,7 @@ bool llvm::InlineFunction(CallSite CS) { // Update PHI nodes that use the ReturnBB to use the AfterCallBB. ReturnBB->replaceAllUsesWith(AfterCallBB); - + // Delete the return instruction now and empty ReturnBB now. Returns[0]->eraseFromParent(); ReturnBB->eraseFromParent(); @@ -323,7 +323,7 @@ bool llvm::InlineFunction(CallSite CS) { // nuke the result. TheCall->replaceAllUsesWith(UndefValue::get(TheCall->getType())); } - + // Since we are now done with the Call/Invoke, we can delete it. TheCall->eraseFromParent(); diff --git a/lib/Transforms/Utils/Local.cpp b/lib/Transforms/Utils/Local.cpp index b188884..915c667 100644 --- a/lib/Transforms/Utils/Local.cpp +++ b/lib/Transforms/Utils/Local.cpp @@ -1,10 +1,10 @@ //===-- Local.cpp - Functions to perform local transformations ------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This family of functions perform various local transformations to the @@ -32,7 +32,7 @@ bool llvm::doConstantPropagation(BasicBlock::iterator &II) { if (Constant *C = ConstantFoldInstruction(II)) { // Replaces all of the uses of a variable with uses of the constant. II->replaceAllUsesWith(C); - + // Remove the instruction from the basic block... II = II->getParent()->getInstList().erase(II); return true; @@ -50,7 +50,7 @@ Constant *llvm::ConstantFoldInstruction(Instruction *I) { if (PHINode *PN = dyn_cast<PHINode>(I)) { if (PN->getNumIncomingValues() == 0) return Constant::getNullValue(PN->getType()); - + Constant *Result = dyn_cast<Constant>(PN->getIncomingValue(0)); if (Result == 0) return 0; @@ -58,7 +58,7 @@ Constant *llvm::ConstantFoldInstruction(Instruction *I) { for (unsigned i = 1, e = PN->getNumIncomingValues(); i != e; ++i) if (PN->getIncomingValue(i) != Result && PN->getIncomingValue(i) != PN) return 0; // Not all the same incoming constants... - + // If we reach here, all incoming values are the same constant. return Result; } else if (CallInst *CI = dyn_cast<CallInst>(I)) { @@ -89,7 +89,7 @@ Constant *llvm::ConstantFoldInstruction(Instruction *I) { } if (isa<BinaryOperator>(I) || isa<ShiftInst>(I)) - return ConstantExpr::get(I->getOpcode(), Op0, Op1); + return ConstantExpr::get(I->getOpcode(), Op0, Op1); switch (I->getOpcode()) { default: return 0; @@ -118,7 +118,7 @@ Constant *llvm::ConstantFoldInstruction(Instruction *I) { // bool llvm::ConstantFoldTerminator(BasicBlock *BB) { TerminatorInst *T = BB->getTerminator(); - + // Branch - See if we are conditional jumping on constant if (BranchInst *BI = dyn_cast<BranchInst>(T)) { if (BI->isUnconditional()) return false; // Can't optimize uncond branch @@ -131,8 +131,8 @@ bool llvm::ConstantFoldTerminator(BasicBlock *BB) { BasicBlock *Destination = Cond->getValue() ? Dest1 : Dest2; BasicBlock *OldDest = Cond->getValue() ? Dest2 : Dest1; - //cerr << "Function: " << T->getParent()->getParent() - // << "\nRemoving branch from " << T->getParent() + //cerr << "Function: " << T->getParent()->getParent() + // << "\nRemoving branch from " << T->getParent() // << "\n\nTo: " << OldDest << endl; // Let the basic block know that we are letting go of it. Based on this, @@ -145,7 +145,7 @@ bool llvm::ConstantFoldTerminator(BasicBlock *BB) { BI->setUnconditionalDest(Destination); return true; } else if (Dest2 == Dest1) { // Conditional branch to same location? - // This branch matches something like this: + // This branch matches something like this: // br bool %cond, label %Dest, label %Dest // and changes it into: br label %Dest @@ -294,7 +294,7 @@ Constant *llvm::ConstantFoldCall(Function *F, if (Name == "llvm.isunordered") return ConstantBool::get(IsNAN(Op1V) || IsNAN(Op2V)); - else + else if (Name == "pow") { errno = 0; double V = pow(Op1V, Op2V); diff --git a/lib/Transforms/Utils/LoopSimplify.cpp b/lib/Transforms/Utils/LoopSimplify.cpp index ba63f9b..3e43126 100644 --- a/lib/Transforms/Utils/LoopSimplify.cpp +++ b/lib/Transforms/Utils/LoopSimplify.cpp @@ -1,10 +1,10 @@ //===- LoopSimplify.cpp - Loop Canonicalization Pass ----------------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This pass performs several transformations to transform natural loops into a @@ -60,7 +60,7 @@ namespace { AliasAnalysis *AA; virtual bool runOnFunction(Function &F); - + virtual void getAnalysisUsage(AnalysisUsage &AU) const { // We need loop information to identify the loops... AU.addRequired<LoopInfo>(); @@ -204,13 +204,13 @@ bool LoopSimplify::ProcessLoop(Loop *L) { BasicBlock *LoopSimplify::SplitBlockPredecessors(BasicBlock *BB, const char *Suffix, const std::vector<BasicBlock*> &Preds) { - + // Create new basic block, insert right before the original block... BasicBlock *NewBB = new BasicBlock(BB->getName()+Suffix, BB->getParent(), BB); // The preheader first gets an unconditional branch to the loop header... BranchInst *BI = new BranchInst(BB, NewBB); - + // For every PHI node in the block, insert a PHI node into NewBB where the // incoming values from the out of loop edges are moved to NewBB. We have two // possible cases here. If the loop is dead, we just insert dummy entries @@ -232,13 +232,13 @@ BasicBlock *LoopSimplify::SplitBlockPredecessors(BasicBlock *BB, InVal = 0; break; } - + // If the values coming into the block are not the same, we need a PHI. if (InVal == 0) { // Create the new PHI node, insert it into NewBB at the end of the block PHINode *NewPHI = new PHINode(PN->getType(), PN->getName()+".ph", BI); if (AA) AA->copyValue(PN, NewPHI); - + // Move all of the edges from blocks outside the loop to the new PHI for (unsigned i = 0, e = Preds.size(); i != e; ++i) { Value *V = PN->removeIncomingValue(Preds[i], false); @@ -266,7 +266,7 @@ BasicBlock *LoopSimplify::SplitBlockPredecessors(BasicBlock *BB, } } } - + // Now that the PHI nodes are updated, actually move the edges from // Preds to point to NewBB instead of BB. // @@ -276,14 +276,14 @@ BasicBlock *LoopSimplify::SplitBlockPredecessors(BasicBlock *BB, if (TI->getSuccessor(s) == BB) TI->setSuccessor(s, NewBB); } - + } else { // Otherwise the loop is dead... for (BasicBlock::iterator I = BB->begin(); isa<PHINode>(I); ++I) { PHINode *PN = cast<PHINode>(I); // Insert dummy values as the incoming value... PN->addIncoming(Constant::getNullValue(PN->getType()), NewBB); } - } + } return NewBB; } @@ -300,15 +300,15 @@ void LoopSimplify::InsertPreheaderForLoop(Loop *L) { PI != PE; ++PI) if (!L->contains(*PI)) // Coming in from outside the loop? OutsideBlocks.push_back(*PI); // Keep track of it... - + // Split out the loop pre-header BasicBlock *NewBB = SplitBlockPredecessors(Header, ".preheader", OutsideBlocks); - + //===--------------------------------------------------------------------===// // Update analysis results now that we have performed the transformation // - + // We know that we have loop information to update... update it now. if (Loop *Parent = L->getParentLoop()) Parent->addBasicBlockToLoop(NewBB, getAnalysis<LoopInfo>()); @@ -330,7 +330,7 @@ void LoopSimplify::InsertPreheaderForLoop(Loop *L) { DominatorSet &DS = getAnalysis<DominatorSet>(); // Update dominator info DominatorTree &DT = getAnalysis<DominatorTree>(); - + // Update the dominator tree information. // The immediate dominator of the preheader is the immediate dominator of @@ -353,16 +353,16 @@ void LoopSimplify::InsertPreheaderForLoop(Loop *L) { E = df_end(PHDomTreeNode); DFI != E; ++DFI) DS.addDominator((*DFI)->getBlock(), NewBB); } - + // Update immediate dominator information if we have it... if (ImmediateDominators *ID = getAnalysisToUpdate<ImmediateDominators>()) { // Whatever i-dominated the header node now immediately dominates NewBB ID->addNewBlock(NewBB, ID->get(Header)); - + // The preheader now is the immediate dominator for the header node... ID->setImmediateDominator(Header, NewBB); } - + // Update dominance frontier information... if (DominanceFrontier *DF = getAnalysisToUpdate<DominanceFrontier>()) { // The DF(NewBB) is just (DF(Header)-Header), because NewBB dominates @@ -405,7 +405,7 @@ void LoopSimplify::InsertPreheaderForLoop(Loop *L) { /// outside of the loop. BasicBlock *LoopSimplify::RewriteLoopExitBlock(Loop *L, BasicBlock *Exit) { DominatorSet &DS = getAnalysis<DominatorSet>(); - + std::vector<BasicBlock*> LoopBlocks; for (pred_iterator I = pred_begin(Exit), E = pred_end(Exit); I != E; ++I) if (L->contains(*I)) @@ -579,7 +579,7 @@ void LoopSimplify::InsertUniqueBackedgeBlock(Loop *L) { // Move the new backedge block to right after the last backedge block. Function::iterator InsertPos = BackedgeBlocks.back(); ++InsertPos; F->getBasicBlockList().splice(InsertPos, F->getBasicBlockList(), BEBlock); - + // Now that the block has been inserted into the function, create PHI nodes in // the backedge block which correspond to any PHI nodes in the header block. for (BasicBlock::iterator I = Header->begin(); isa<PHINode>(I); ++I) { @@ -609,7 +609,7 @@ void LoopSimplify::InsertUniqueBackedgeBlock(Loop *L) { } } } - + // Delete all of the incoming values from the old PN except the preheader's assert(PreheaderIdx != ~0U && "PHI has no preheader entry??"); if (PreheaderIdx != 0) { @@ -825,7 +825,7 @@ void LoopSimplify::UpdateDomInfoForRevectoredPreds(BasicBlock *NewBB, for (DominatorSet::DomSetType::const_iterator PDI = PredDoms.begin(), PDE = PredDoms.end(); PDI != PDE; ++PDI) { BasicBlock *PredDom = *PDI; - + // If the NewBBSucc node is in DF(PredDom), then PredDom didn't // dominate NewBBSucc but did dominate a predecessor of it. Now we // change this entry to include NewBB in the DF instead of NewBBSucc. @@ -846,7 +846,7 @@ void LoopSimplify::UpdateDomInfoForRevectoredPreds(BasicBlock *NewBB, break; } } - + if (ShouldRemove) DF->removeFromFrontier(DFI, NewBBSucc); DF->addToFrontier(DFI, NewBB); diff --git a/lib/Transforms/Utils/LowerAllocations.cpp b/lib/Transforms/Utils/LowerAllocations.cpp index abed41ed..71b45fd 100644 --- a/lib/Transforms/Utils/LowerAllocations.cpp +++ b/lib/Transforms/Utils/LowerAllocations.cpp @@ -1,10 +1,10 @@ //===- LowerAllocations.cpp - Reduce malloc & free insts to calls ---------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // The LowerAllocations transformation is a target-dependent tranformation @@ -49,7 +49,7 @@ namespace { virtual bool doInitialization(Function &F) { return BasicBlockPass::doInitialization(F); } - + /// runOnBasicBlock - This method does the actual work of converting /// instructions over, assuming that the pass has already been initialized. /// @@ -104,7 +104,7 @@ bool LowerAllocations::runOnBasicBlock(BasicBlock &BB) { for (BasicBlock::iterator I = BB.begin(), E = BB.end(); I != E; ++I) { if (MallocInst *MI = dyn_cast<MallocInst>(I)) { const Type *AllocTy = MI->getType()->getElementType(); - + // malloc(type) becomes sbyte *malloc(size) Value *MallocArg; if (LowerMallocArgToInteger) @@ -133,7 +133,7 @@ bool LowerAllocations::runOnBasicBlock(BasicBlock &BB) { const FunctionType *MallocFTy = MallocFunc->getFunctionType(); std::vector<Value*> MallocArgs; - + if (MallocFTy->getNumParams() > 0 || MallocFTy->isVarArg()) { if (MallocFTy->isVarArg()) { if (MallocArg->getType() != IntPtrTy) @@ -150,14 +150,14 @@ bool LowerAllocations::runOnBasicBlock(BasicBlock &BB) { // Create the call to Malloc... CallInst *MCall = new CallInst(MallocFunc, MallocArgs, "", I); - + // Create a cast instruction to convert to the right type... Value *MCast; if (MCall->getType() != Type::VoidTy) MCast = new CastInst(MCall, MI->getType(), "", I); else MCast = Constant::getNullValue(MI->getType()); - + // Replace all uses of the old malloc inst with the cast inst MI->replaceAllUsesWith(MCast); I = --BBIL.erase(I); // remove and delete the malloc instr... @@ -166,7 +166,7 @@ bool LowerAllocations::runOnBasicBlock(BasicBlock &BB) { } else if (FreeInst *FI = dyn_cast<FreeInst>(I)) { const FunctionType *FreeFTy = FreeFunc->getFunctionType(); std::vector<Value*> FreeArgs; - + if (FreeFTy->getNumParams() > 0 || FreeFTy->isVarArg()) { Value *MCast = FI->getOperand(0); if (FreeFTy->getNumParams() > 0 && @@ -178,10 +178,10 @@ bool LowerAllocations::runOnBasicBlock(BasicBlock &BB) { // If malloc is prototyped to take extra arguments, pass nulls. for (unsigned i = 1; i < FreeFTy->getNumParams(); ++i) FreeArgs.push_back(Constant::getNullValue(FreeFTy->getParamType(i))); - + // Insert a call to the free function... new CallInst(FreeFunc, FreeArgs, "", I); - + // Delete the old free instruction I = --BBIL.erase(I); Changed = true; diff --git a/lib/Transforms/Utils/LowerInvoke.cpp b/lib/Transforms/Utils/LowerInvoke.cpp index 97c2327..08249c6 100644 --- a/lib/Transforms/Utils/LowerInvoke.cpp +++ b/lib/Transforms/Utils/LowerInvoke.cpp @@ -1,10 +1,10 @@ //===- LowerInvoke.cpp - Eliminate Invoke & Unwind instructions -----------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This transformation is designed for use by code generators which do not yet @@ -153,7 +153,7 @@ void LowerInvoke::createAbortMessage() { Constant *Msg = ConstantArray::get("ERROR: Exception thrown, but not caught!\n"); AbortMessageLength = Msg->getNumOperands()-1; // don't include \0 - + GlobalVariable *MsgGV = new GlobalVariable(Msg->getType(), true, GlobalValue::InternalLinkage, Msg, "abortmsg", &M); @@ -192,7 +192,7 @@ void LowerInvoke::writeAbortMessage(Instruction *IB) { unsigned NumArgs = FT->getNumParams(); for (unsigned i = 0; i != 3; ++i) if (i < NumArgs && FT->getParamType(i) != Args[i]->getType()) - Args[i] = ConstantExpr::getCast(cast<Constant>(Args[i]), + Args[i] = ConstantExpr::getCast(cast<Constant>(Args[i]), FT->getParamType(i)); new CallInst(WriteFn, Args, "", IB); @@ -209,7 +209,7 @@ bool LowerInvoke::insertCheapEHSupport(Function &F) { std::vector<Value*>(II->op_begin()+3, II->op_end()), Name,II); II->replaceAllUsesWith(NewCall); - + // Insert an unconditional branch to the normal destination. new BranchInst(II->getNormalDest(), II); @@ -269,7 +269,7 @@ bool LowerInvoke::insertExpensiveEHSupport(Function &F) { Value *NextFieldPtr = new GetElementPtrInst(JmpBuf, Idx, "NextField", II); new StoreInst(OldEntry, NextFieldPtr, II); new StoreInst(JmpBuf, JBListHead, II); - + // Call setjmp, passing in the address of the jmpbuffer. Idx[1] = ConstantUInt::get(Type::UIntTy, 1); Value *JmpBufPtr = new GetElementPtrInst(JmpBuf, Idx, "TheJmpBuf", II); @@ -283,7 +283,7 @@ bool LowerInvoke::insertExpensiveEHSupport(Function &F) { // destination. SplitCriticalEdge(II, 0, this); Instruction *InsertLoc = II->getNormalDest()->begin(); - + // Insert a normal call instruction on the normal execution path. std::string Name = II->getName(); II->setName(""); Value *NewCall = new CallInst(II->getCalledValue(), @@ -291,7 +291,7 @@ bool LowerInvoke::insertExpensiveEHSupport(Function &F) { II->op_end()), Name, InsertLoc); II->replaceAllUsesWith(NewCall); - + // If we got this far, then no exception was thrown and we can pop our // jmpbuf entry off. new StoreInst(OldEntry, JBListHead, InsertLoc); @@ -301,8 +301,8 @@ bool LowerInvoke::insertExpensiveEHSupport(Function &F) { // Remove the InvokeInst now. BB->getInstList().erase(II); - ++NumLowered; Changed = true; - + ++NumLowered; Changed = true; + } else if (UnwindInst *UI = dyn_cast<UnwindInst>(BB->getTerminator())) { if (UnwindBlock == 0) { // Create two new blocks, the unwind block and the terminate block. Add @@ -330,7 +330,7 @@ bool LowerInvoke::insertExpensiveEHSupport(Function &F) { // Remove the UnwindInst now. BB->getInstList().erase(UI); - ++NumLowered; Changed = true; + ++NumLowered; Changed = true; } // If an unwind instruction was inserted, we need to set up the Unwind and @@ -370,7 +370,7 @@ bool LowerInvoke::insertExpensiveEHSupport(Function &F) { // Now we set up the terminate block. RI = TermBlock->getTerminator(); - + // Insert a new call to write(2, AbortMessage, AbortMessageLength); writeAbortMessage(RI); diff --git a/lib/Transforms/Utils/LowerSelect.cpp b/lib/Transforms/Utils/LowerSelect.cpp index f914e74..7555768 100644 --- a/lib/Transforms/Utils/LowerSelect.cpp +++ b/lib/Transforms/Utils/LowerSelect.cpp @@ -1,10 +1,10 @@ //===- LowerSelect.cpp - Transform select insts to branches ---------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This pass lowers select instructions into conditional branches for targets @@ -86,7 +86,7 @@ bool LowerSelect::runOnFunction(Function &F) { // Use the PHI instead of the select. SI->replaceAllUsesWith(PN); NewCont->getInstList().erase(SI); - + Changed = true; break; // This block is done with. } diff --git a/lib/Transforms/Utils/LowerSwitch.cpp b/lib/Transforms/Utils/LowerSwitch.cpp index 242343f..0ba37c2 100644 --- a/lib/Transforms/Utils/LowerSwitch.cpp +++ b/lib/Transforms/Utils/LowerSwitch.cpp @@ -1,10 +1,10 @@ //===- LowerSwitch.cpp - Eliminate Switch instructions --------------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // The LowerSwitch transformation rewrites switch statements with a sequence of diff --git a/lib/Transforms/Utils/Mem2Reg.cpp b/lib/Transforms/Utils/Mem2Reg.cpp index 1c8fa3b..77c72fe 100644 --- a/lib/Transforms/Utils/Mem2Reg.cpp +++ b/lib/Transforms/Utils/Mem2Reg.cpp @@ -1,10 +1,10 @@ //===- Mem2Reg.cpp - The -mem2reg pass, a wrapper around the Utils lib ----===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This pass is a simple pass wrapper around the PromoteMemToReg function call @@ -53,7 +53,7 @@ bool PromotePass::runOnFunction(Function &F) { DominatorTree &DT = getAnalysis<DominatorTree>(); DominanceFrontier &DF = getAnalysis<DominanceFrontier>(); - + while (1) { Allocas.clear(); diff --git a/lib/Transforms/Utils/PromoteMemoryToRegister.cpp b/lib/Transforms/Utils/PromoteMemoryToRegister.cpp index ff68f4e..37f4604 100644 --- a/lib/Transforms/Utils/PromoteMemoryToRegister.cpp +++ b/lib/Transforms/Utils/PromoteMemoryToRegister.cpp @@ -1,10 +1,10 @@ //===- PromoteMemoryToRegister.cpp - Convert allocas to registers ---------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file promote memory references to be register references. It promotes @@ -48,7 +48,7 @@ bool llvm::isAllocaPromotable(const AllocaInst *AI, const TargetData &TD) { } else { return false; // Not a load or store. } - + return true; } @@ -107,7 +107,7 @@ namespace { void MarkDominatingPHILive(BasicBlock *BB, unsigned AllocaNum, std::set<PHINode*> &DeadPHINodes); void PromoteLocallyUsedAlloca(BasicBlock *BB, AllocaInst *AI); - void PromoteLocallyUsedAllocas(BasicBlock *BB, + void PromoteLocallyUsedAllocas(BasicBlock *BB, const std::vector<AllocaInst*> &AIs); void RenamePass(BasicBlock *BB, BasicBlock *Pred, @@ -267,13 +267,13 @@ void PromoteMem2Reg::run() { if (AST && isa<PointerType>(PN->getType())) AST->deleteValue(PN); - PN->getParent()->getInstList().erase(PN); + PN->getParent()->getInstList().erase(PN); } - // Keep the reverse mapping of the 'Allocas' array. + // Keep the reverse mapping of the 'Allocas' array. AllocaLookup[Allocas[AllocaNum]] = AllocaNum; } - + // Process all allocas which are only used in a single basic block. for (std::map<BasicBlock*, std::vector<AllocaInst*> >::iterator I = LocallyUsedAllocas.begin(), E = LocallyUsedAllocas.end(); I != E; ++I){ @@ -327,7 +327,7 @@ void PromoteMem2Reg::run() { // have incoming values for all predecessors. Loop over all PHI nodes we have // created, inserting undef values if they are missing any incoming values. // - for (std::map<BasicBlock*, std::vector<PHINode *> >::iterator I = + for (std::map<BasicBlock*, std::vector<PHINode *> >::iterator I = NewPhiNodes.begin(), E = NewPhiNodes.end(); I != E; ++I) { std::vector<BasicBlock*> Preds(pred_begin(I->first), pred_end(I->first)); @@ -449,7 +449,7 @@ void PromoteMem2Reg::PromoteLocallyUsedAlloca(BasicBlock *BB, AllocaInst *AI) { } else { // Uses of the uninitialized memory location shall get undef. Value *CurVal = UndefValue::get(AI->getAllocatedType()); - + for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ) { Instruction *Inst = I++; if (LoadInst *LI = dyn_cast<LoadInst>(Inst)) { @@ -572,7 +572,7 @@ void PromoteMem2Reg::RenamePass(BasicBlock *BB, BasicBlock *Pred, // don't revisit nodes if (Visited.count(BB)) return; - + // mark as visited Visited.insert(BB); diff --git a/lib/Transforms/Utils/SimplifyCFG.cpp b/lib/Transforms/Utils/SimplifyCFG.cpp index 986a53f..5f023f1 100644 --- a/lib/Transforms/Utils/SimplifyCFG.cpp +++ b/lib/Transforms/Utils/SimplifyCFG.cpp @@ -1,10 +1,10 @@ //===- SimplifyCFG.cpp - Code to perform CFG simplification ---------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // Peephole optimize the CFG. @@ -81,7 +81,7 @@ static bool PropagatePredecessorsForPHIs(BasicBlock *BB, BasicBlock *Succ) { PN->addIncoming(OldValPN->getIncomingValue(i), OldValPN->getIncomingBlock(i)); } else { - for (std::vector<BasicBlock*>::const_iterator PredI = BBPreds.begin(), + for (std::vector<BasicBlock*>::const_iterator PredI = BBPreds.begin(), End = BBPreds.end(); PredI != End; ++PredI) { // Add an incoming value for each of the new incoming values... PN->addIncoming(OldVal, *PredI); @@ -97,7 +97,7 @@ static bool PropagatePredecessorsForPHIs(BasicBlock *BB, BasicBlock *Succ) { /// which entry into BB will be taken. Also, return by references the block /// that will be entered from if the condition is true, and the block that will /// be entered if the condition is false. -/// +/// /// static Value *GetIfCondition(BasicBlock *BB, BasicBlock *&IfTrue, BasicBlock *&IfFalse) { @@ -240,7 +240,7 @@ static bool DominatesMergePoint(Value *V, BasicBlock *BB, case Instruction::SetGE: break; // These are all cheap and non-trapping instructions. } - + // Okay, we can only really hoist these out if their operands are not // defined in the conditional region. for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) @@ -317,7 +317,7 @@ static bool GatherValueComparisons(Instruction *Cond, Value *&CompVal, return true; } else if (Cond->getOpcode() == Instruction::And) { CompVal = GatherConstantSetNEs(Cond, Values); - + // Return false to indicate that the condition is false if the CompVal is // equal to one of the constants. return false; @@ -360,7 +360,7 @@ static bool SafeToMergeTerminators(TerminatorInst *SI1, TerminatorInst *SI2) { PN->getIncomingValueForBlock(SI2BB)) return false; } - + return true; } @@ -397,7 +397,7 @@ static Value *isValueEqualityComparison(TerminatorInst *TI) { if (BI->isConditional() && BI->getCondition()->hasOneUse()) if (SetCondInst *SCI = dyn_cast<SetCondInst>(BI->getCondition())) if ((SCI->getOpcode() == Instruction::SetEQ || - SCI->getOpcode() == Instruction::SetNE) && + SCI->getOpcode() == Instruction::SetNE) && isa<ConstantInt>(SCI->getOperand(1))) return SCI->getOperand(0); return 0; @@ -406,7 +406,7 @@ static Value *isValueEqualityComparison(TerminatorInst *TI) { // Given a value comparison instruction, decode all of the 'cases' that it // represents and return the 'default' block. static BasicBlock * -GetValueEqualityComparisonCases(TerminatorInst *TI, +GetValueEqualityComparisonCases(TerminatorInst *TI, std::vector<std::pair<ConstantInt*, BasicBlock*> > &Cases) { if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) { @@ -427,7 +427,7 @@ GetValueEqualityComparisonCases(TerminatorInst *TI, // EliminateBlockCases - Given an vector of bb/value pairs, remove any entries // in the list that match the specified block. -static void EliminateBlockCases(BasicBlock *BB, +static void EliminateBlockCases(BasicBlock *BB, std::vector<std::pair<ConstantInt*, BasicBlock*> > &Cases) { for (unsigned i = 0, e = Cases.size(); i != e; ++i) if (Cases[i].second == BB) { @@ -491,7 +491,7 @@ static bool SimplifyEqualityComparisonWithOnlyPredecessor(TerminatorInst *TI, BasicBlock *PredDef = GetValueEqualityComparisonCases(Pred->getTerminator(), PredCases); EliminateBlockCases(PredDef, PredCases); // Remove default from cases. - + // Find information about how control leaves this block. std::vector<std::pair<ConstantInt*, BasicBlock*> > ThisCases; BasicBlock *ThisDef = GetValueEqualityComparisonCases(TI, ThisCases); @@ -608,7 +608,7 @@ static bool FoldValueComparisonIntoPredecessors(TerminatorInst *TI) { while (!Preds.empty()) { BasicBlock *Pred = Preds.back(); Preds.pop_back(); - + // See if the predecessor is a comparison with the same value. TerminatorInst *PTI = Pred->getTerminator(); Value *PCV = isValueEqualityComparison(PTI); // PredCondVal @@ -719,7 +719,7 @@ static bool FoldValueComparisonIntoPredecessors(TerminatorInst *TI) { } NewSI->setSuccessor(i, InfLoopBlock); } - + Changed = true; } } @@ -750,7 +750,7 @@ static bool HoistThenElseCodeToIf(BranchInst *BI) { // broken BB), instead clone it, and remove BI. if (isa<TerminatorInst>(I1)) goto HoistTerminator; - + // For a normal instruction, we just move one to right before the branch, // then replace all uses of the other with the first. Finally, we remove // the now redundant second instruction. @@ -758,7 +758,7 @@ static bool HoistThenElseCodeToIf(BranchInst *BI) { if (!I2->use_empty()) I2->replaceAllUsesWith(I1); BB2->getInstList().erase(I2); - + I1 = BB1->begin(); I2 = BB2->begin(); } while (I1->getOpcode() == I2->getOpcode() && I1->isIdenticalTo(I2)); @@ -804,7 +804,7 @@ HoistTerminator: // Update any PHI nodes in our new successors. for (succ_iterator SI = succ_begin(BB1), E = succ_end(BB1); SI != E; ++SI) AddPredecessorToBlock(*SI, BIParent, BB1); - + BI->eraseFromParent(); return true; } @@ -850,13 +850,13 @@ bool llvm::SimplifyCFG(BasicBlock *BB) { Instruction &I = BB->back(); // If this instruction is used, replace uses with an arbitrary // constant value. Because control flow can't get here, we don't care - // what we replace the value with. Note that since this block is + // what we replace the value with. Note that since this block is // unreachable, and all values contained within it must dominate their // uses, that all uses will eventually be removed. - if (!I.use_empty()) + if (!I.use_empty()) // Make all users of this instruction reference the constant instead I.replaceAllUsesWith(Constant::getNullValue(I.getType())); - + // Remove the instruction from the basic block BB->getInstList().pop_back(); } @@ -886,11 +886,11 @@ bool llvm::SimplifyCFG(BasicBlock *BB) { // if (!PropagatePredecessorsForPHIs(BB, Succ)) { DEBUG(std::cerr << "Killing Trivial BB: \n" << *BB); - + if (isa<PHINode>(&BB->front())) { std::vector<BasicBlock*> OldSuccPreds(pred_begin(Succ), pred_end(Succ)); - + // Move all PHI nodes in BB to Succ if they are alive, otherwise // delete them. while (PHINode *PN = dyn_cast<PHINode>(&BB->front())) @@ -903,7 +903,7 @@ bool llvm::SimplifyCFG(BasicBlock *BB) { // strictly dominated Succ. BB->getInstList().remove(BB->begin()); Succ->getInstList().push_front(PN); - + // We need to add new entries for the PHI node to account for // predecessors of Succ that the PHI node does not take into // account. At this point, since we know that BB dominated succ, @@ -915,7 +915,7 @@ bool llvm::SimplifyCFG(BasicBlock *BB) { PN->addIncoming(PN, OldSuccPreds[i]); } } - + // Everything that jumped to BB now goes to Succ. std::string OldName = BB->getName(); BB->replaceAllUsesWith(Succ); @@ -948,7 +948,7 @@ bool llvm::SimplifyCFG(BasicBlock *BB) { else CondBranchPreds.push_back(BI); } - + // If we found some, do the transformation! if (!UncondBranchPreds.empty()) { while (!UncondBranchPreds.empty()) { @@ -1061,7 +1061,7 @@ bool llvm::SimplifyCFG(BasicBlock *BB) { // is now a fall through... BranchInst *BI = new BranchInst(II->getNormalDest(), II); Pred->getInstList().remove(II); // Take out of symbol table - + // Insert the call now... std::vector<Value*> Args(II->op_begin()+3, II->op_end()); CallInst *CI = new CallInst(II->getCalledValue(), Args, @@ -1071,7 +1071,7 @@ bool llvm::SimplifyCFG(BasicBlock *BB) { delete II; Changed = true; } - + Preds.pop_back(); } @@ -1153,7 +1153,7 @@ bool llvm::SimplifyCFG(BasicBlock *BB) { Instruction::BinaryOps Opcode = PBI->getSuccessor(0) == TrueDest ? Instruction::Or : Instruction::And; - Value *NewCond = + Value *NewCond = BinaryOperator::create(Opcode, PBI->getCondition(), New, "bothcond", PBI); PBI->setCondition(NewCond); @@ -1179,7 +1179,7 @@ bool llvm::SimplifyCFG(BasicBlock *BB) { OnlyPred = 0; // There are multiple different predecessors... break; } - + if (OnlyPred) if (BranchInst *PBI = dyn_cast<BranchInst>(OnlyPred->getTerminator())) if (PBI->isConditional() && @@ -1275,7 +1275,7 @@ bool llvm::SimplifyCFG(BasicBlock *BB) { // place to note that the call does not throw though. BranchInst *BI = new BranchInst(II->getNormalDest(), II); II->removeFromParent(); // Take out of symbol table - + // Insert the call now... std::vector<Value*> Args(II->op_begin()+3, II->op_end()); CallInst *CI = new CallInst(II->getCalledValue(), Args, @@ -1339,23 +1339,23 @@ bool llvm::SimplifyCFG(BasicBlock *BB) { // Delete the unconditional branch from the predecessor... OnlyPred->getInstList().pop_back(); - + // Move all definitions in the successor to the predecessor... OnlyPred->getInstList().splice(OnlyPred->end(), BB->getInstList()); - + // Make all PHI nodes that referred to BB now refer to Pred as their // source... BB->replaceAllUsesWith(OnlyPred); std::string OldName = BB->getName(); - // Erase basic block from the function... + // Erase basic block from the function... M->getBasicBlockList().erase(BB); // Inherit predecessors name if it exists... if (!OldName.empty() && !OnlyPred->hasName()) OnlyPred->setName(OldName); - + return true; } @@ -1393,19 +1393,19 @@ bool llvm::SimplifyCFG(BasicBlock *BB) { // instruction can't handle, remove them now. std::sort(Values.begin(), Values.end(), ConstantIntOrdering()); Values.erase(std::unique(Values.begin(), Values.end()), Values.end()); - + // Figure out which block is which destination. BasicBlock *DefaultBB = BI->getSuccessor(1); BasicBlock *EdgeBB = BI->getSuccessor(0); if (!TrueWhenEqual) std::swap(DefaultBB, EdgeBB); - + // Create the new switch instruction now. SwitchInst *New = new SwitchInst(CompVal, DefaultBB,Values.size(),BI); - + // Add all of the 'cases' to the switch instruction. for (unsigned i = 0, e = Values.size(); i != e; ++i) New->addCase(Values[i], EdgeBB); - + // We added edges from PI to the EdgeBB. As such, if there were any // PHI nodes in EdgeBB, they need entries to be added corresponding to // the number of edges added. @@ -1489,7 +1489,7 @@ bool llvm::SimplifyCFG(BasicBlock *BB) { } Pred = PN->getIncomingBlock(1); - if (CanPromote && + if (CanPromote && cast<BranchInst>(Pred->getTerminator())->isUnconditional()) { IfBlock2 = Pred; DomBlock = *pred_begin(Pred); @@ -1539,6 +1539,6 @@ bool llvm::SimplifyCFG(BasicBlock *BB) { } } } - + return Changed; } diff --git a/lib/Transforms/Utils/UnifyFunctionExitNodes.cpp b/lib/Transforms/Utils/UnifyFunctionExitNodes.cpp index 9776163..0c1eda7 100644 --- a/lib/Transforms/Utils/UnifyFunctionExitNodes.cpp +++ b/lib/Transforms/Utils/UnifyFunctionExitNodes.cpp @@ -1,10 +1,10 @@ //===- UnifyFunctionExitNodes.cpp - Make all functions have a single exit -===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This pass is used to ensure that functions have at most one return @@ -64,7 +64,7 @@ bool UnifyFunctionExitNodes::runOnFunction(Function &F) { UnwindBlock = new BasicBlock("UnifiedUnwindBlock", &F); new UnwindInst(UnwindBlock); - for (std::vector<BasicBlock*>::iterator I = UnwindingBlocks.begin(), + for (std::vector<BasicBlock*>::iterator I = UnwindingBlocks.begin(), E = UnwindingBlocks.end(); I != E; ++I) { BasicBlock *BB = *I; BB->getInstList().pop_back(); // Remove the unwind insn @@ -81,7 +81,7 @@ bool UnifyFunctionExitNodes::runOnFunction(Function &F) { UnreachableBlock = new BasicBlock("UnifiedUnreachableBlock", &F); new UnreachableInst(UnreachableBlock); - for (std::vector<BasicBlock*>::iterator I = UnreachableBlocks.begin(), + for (std::vector<BasicBlock*>::iterator I = UnreachableBlocks.begin(), E = UnreachableBlocks.end(); I != E; ++I) { BasicBlock *BB = *I; BB->getInstList().pop_back(); // Remove the unreachable inst. @@ -99,7 +99,7 @@ bool UnifyFunctionExitNodes::runOnFunction(Function &F) { } // Otherwise, we need to insert a new basic block into the function, add a PHI - // node (if the function returns a value), and convert all of the return + // node (if the function returns a value), and convert all of the return // instructions into unconditional branches. // BasicBlock *NewRetBlock = new BasicBlock("UnifiedReturnBlock", &F); @@ -115,7 +115,7 @@ bool UnifyFunctionExitNodes::runOnFunction(Function &F) { // Loop over all of the blocks, replacing the return instruction with an // unconditional branch. // - for (std::vector<BasicBlock*>::iterator I = ReturningBlocks.begin(), + for (std::vector<BasicBlock*>::iterator I = ReturningBlocks.begin(), E = ReturningBlocks.end(); I != E; ++I) { BasicBlock *BB = *I; diff --git a/lib/Transforms/Utils/ValueMapper.cpp b/lib/Transforms/Utils/ValueMapper.cpp index 299a093..ef03c6c 100644 --- a/lib/Transforms/Utils/ValueMapper.cpp +++ b/lib/Transforms/Utils/ValueMapper.cpp @@ -1,10 +1,10 @@ //===- ValueMapper.cpp - Interface shared by lib/Transforms/Utils ---------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file defines the MapValue function, which is shared by various parts of @@ -23,7 +23,7 @@ using namespace llvm; Value *llvm::MapValue(const Value *V, std::map<const Value*, Value*> &VM) { Value *&VMSlot = VM[V]; if (VMSlot) return VMSlot; // Does it exist in the map yet? - + // Global values do not need to be seeded into the ValueMap if they are using // the identity mapping. if (isa<GlobalValue>(V)) diff --git a/lib/Transforms/Utils/ValueMapper.h b/lib/Transforms/Utils/ValueMapper.h index a0ad5c3..c768671 100644 --- a/lib/Transforms/Utils/ValueMapper.h +++ b/lib/Transforms/Utils/ValueMapper.h @@ -1,10 +1,10 @@ //===- ValueMapper.h - Interface shared by lib/Transforms/Utils -*- C++ -*-===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file defines the MapValue interface which is used by various parts of diff --git a/lib/VMCore/AsmWriter.cpp b/lib/VMCore/AsmWriter.cpp index 1049f96..18d045f 100644 --- a/lib/VMCore/AsmWriter.cpp +++ b/lib/VMCore/AsmWriter.cpp @@ -1,10 +1,10 @@ //===-- AsmWriter.cpp - Printing LLVM as an assembly file -----------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This library implements the functionality defined in llvm/Assembly/Writer.h @@ -46,7 +46,7 @@ public: typedef std::map<const Type*, unsigned> TypeMap; /// @brief A plane with next slot number and ValueMap - struct ValuePlane { + struct ValuePlane { unsigned next_slot; ///< The next slot number to use ValueMap map; ///< The map of Value* -> unsigned ValuePlane() { next_slot = 0; } ///< Make sure we start at 0 @@ -90,15 +90,15 @@ public: /// @name Mutators /// @{ public: - /// If you'd like to deal with a function instead of just a module, use + /// If you'd like to deal with a function instead of just a module, use /// this method to get its data into the SlotMachine. - void incorporateFunction(const Function *F) { - TheFunction = F; + void incorporateFunction(const Function *F) { + TheFunction = F; FunctionProcessed = false; } - /// After calling incorporateFunction, use this method to remove the - /// most recently incorporated function from the SlotMachine. This + /// After calling incorporateFunction, use this method to remove the + /// most recently incorporated function from the SlotMachine. This /// will reset the state of the machine back to just the module contents. void purgeFunction(); @@ -109,7 +109,7 @@ private: /// This function does the actual initialization. inline void initialize(); - /// Values can be crammed into here at will. If they haven't + /// Values can be crammed into here at will. If they haven't /// been inserted already, they get inserted, otherwise they are ignored. /// Either way, the slot number for the Value* is returned. unsigned createSlot(const Value *V); @@ -117,7 +117,7 @@ private: /// Insert a value into the value table. Return the slot number /// that it now occupies. BadThings(TM) will happen if you insert a - /// Value that's already been inserted. + /// Value that's already been inserted. unsigned insertValue( const Value *V ); unsigned insertValue( const Type* Ty); @@ -162,12 +162,12 @@ X("printm", "Print module to stderr",PassInfo::Analysis|PassInfo::Optimization); static RegisterPass<PrintFunctionPass> Y("print","Print function to stderr",PassInfo::Analysis|PassInfo::Optimization); -static void WriteAsOperandInternal(std::ostream &Out, const Value *V, +static void WriteAsOperandInternal(std::ostream &Out, const Value *V, bool PrintName, std::map<const Type *, std::string> &TypeTable, SlotMachine *Machine); -static void WriteAsOperandInternal(std::ostream &Out, const Type *T, +static void WriteAsOperandInternal(std::ostream &Out, const Type *T, bool PrintName, std::map<const Type *, std::string> &TypeTable, SlotMachine *Machine); @@ -219,7 +219,7 @@ static std::string getLLVMName(const std::string &Name, C != '-' && C != '.' && C != '_') return "\"" + Name + "\""; } - + // If we get here, then the identifier is legal to use as a "VarID". if (prefixName) return "%"+Name; @@ -250,7 +250,7 @@ static void fillTypeNameTable(const Module *M, -static void calcTypeName(const Type *Ty, +static void calcTypeName(const Type *Ty, std::vector<const Type *> &TypeStack, std::map<const Type *, std::string> &TypeNames, std::string & Result){ @@ -275,7 +275,7 @@ static void calcTypeName(const Type *Ty, unsigned Slot = 0, CurSize = TypeStack.size(); while (Slot < CurSize && TypeStack[Slot] != Ty) ++Slot; // Scan for type - // This is another base case for the recursion. In this case, we know + // This is another base case for the recursion. In this case, we know // that we have looped back to a type that we have previously visited. // Generate the appropriate upreference to handle this. if (Slot < CurSize) { @@ -284,7 +284,7 @@ static void calcTypeName(const Type *Ty, } TypeStack.push_back(Ty); // Recursive case: Add us to the stack.. - + switch (Ty->getTypeID()) { case Type::FunctionTyID: { const FunctionType *FTy = cast<FunctionType>(Ty); @@ -316,7 +316,7 @@ static void calcTypeName(const Type *Ty, break; } case Type::PointerTyID: - calcTypeName(cast<PointerType>(Ty)->getElementType(), + calcTypeName(cast<PointerType>(Ty)->getElementType(), TypeStack, TypeNames, Result); Result += "*"; break; @@ -379,22 +379,22 @@ static std::ostream &printTypeInt(std::ostream &Out, const Type *Ty, /// std::ostream &llvm::WriteTypeSymbolic(std::ostream &Out, const Type *Ty, const Module *M) { - Out << ' '; + Out << ' '; // If they want us to print out a type, attempt to make it symbolic if there // is a symbol table in the module... if (M) { std::map<const Type *, std::string> TypeNames; fillTypeNameTable(M, TypeNames); - + return printTypeInt(Out, Ty, TypeNames); } else { return Out << Ty->getDescription(); } } -/// @brief Internal constant writer. -static void WriteConstantInt(std::ostream &Out, const Constant *CV, +/// @brief Internal constant writer. +static void WriteConstantInt(std::ostream &Out, const Constant *CV, bool PrintName, std::map<const Type *, std::string> &TypeTable, SlotMachine *Machine) { @@ -424,7 +424,7 @@ static void WriteConstantInt(std::ostream &Out, const Constant *CV, Out << StrVal; return; } - + // Otherwise we could not reparse it to exactly the same value, so we must // output the string in hexadecimal format! // @@ -445,7 +445,7 @@ static void WriteConstantInt(std::ostream &Out, const Constant *CV, } else if (const ConstantArray *CA = dyn_cast<ConstantArray>(CV)) { // As a special case, print the array as a string if it is an array of // ubytes or an array of sbytes with positive values. - // + // const Type *ETy = CA->getType()->getElementType(); bool isString = (ETy == Type::SByteTy || ETy == Type::UByteTy); @@ -459,9 +459,9 @@ static void WriteConstantInt(std::ostream &Out, const Constant *CV, if (isString) { Out << "c\""; for (unsigned i = 0; i < CA->getNumOperands(); ++i) { - unsigned char C = + unsigned char C = (unsigned char)cast<ConstantInt>(CA->getOperand(i))->getRawValue(); - + if (isprint(C) && C != '"' && C != '\\') { Out << C; } else { @@ -509,7 +509,7 @@ static void WriteConstantInt(std::ostream &Out, const Constant *CV, Out << " }"; } else if (const ConstantPacked *CP = dyn_cast<ConstantPacked>(CV)) { const Type *ETy = CP->getType()->getElementType(); - assert(CP->getNumOperands() > 0 && + assert(CP->getNumOperands() > 0 && "Number of operands for a PackedConst must be > 0"); Out << '<'; Out << ' '; @@ -531,14 +531,14 @@ static void WriteConstantInt(std::ostream &Out, const Constant *CV, } else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) { Out << CE->getOpcodeName() << " ("; - + for (User::const_op_iterator OI=CE->op_begin(); OI != CE->op_end(); ++OI) { printTypeInt(Out, (*OI)->getType(), TypeTable); WriteAsOperandInternal(Out, *OI, PrintName, TypeTable, Machine); if (OI+1 != CE->op_end()) Out << ", "; } - + if (CE->getOpcode() == Instruction::Cast) { Out << " to "; printTypeInt(Out, CE->getType(), TypeTable); @@ -555,7 +555,7 @@ static void WriteConstantInt(std::ostream &Out, const Constant *CV, /// ostream. This can be useful when you just want to print int %reg126, not /// the whole instruction that generated it. /// -static void WriteAsOperandInternal(std::ostream &Out, const Value *V, +static void WriteAsOperandInternal(std::ostream &Out, const Value *V, bool PrintName, std::map<const Type*, std::string> &TypeTable, SlotMachine *Machine) { @@ -572,7 +572,7 @@ static void WriteAsOperandInternal(std::ostream &Out, const Value *V, Slot = Machine->getSlot(V); } else { Machine = createSlotMachine(V); - if (Machine == 0) + if (Machine == 0) Slot = Machine->getSlot(V); else Slot = -1; @@ -591,7 +591,7 @@ static void WriteAsOperandInternal(std::ostream &Out, const Value *V, /// the whole instruction that generated it. /// std::ostream &llvm::WriteAsOperand(std::ostream &Out, const Value *V, - bool PrintType, bool PrintName, + bool PrintType, bool PrintName, const Module *Context) { std::map<const Type *, std::string> TypeNames; if (Context == 0) Context = getModuleFromVal(V); @@ -601,16 +601,16 @@ std::ostream &llvm::WriteAsOperand(std::ostream &Out, const Value *V, if (PrintType) printTypeInt(Out, V->getType(), TypeNames); - + WriteAsOperandInternal(Out, V, PrintName, TypeNames, 0); return Out; } -/// WriteAsOperandInternal - Write the name of the specified value out to -/// the specified ostream. This can be useful when you just want to print +/// WriteAsOperandInternal - Write the name of the specified value out to +/// the specified ostream. This can be useful when you just want to print /// int %reg126, not the whole instruction that generated it. /// -static void WriteAsOperandInternal(std::ostream &Out, const Type *T, +static void WriteAsOperandInternal(std::ostream &Out, const Type *T, bool PrintName, std::map<const Type*, std::string> &TypeTable, SlotMachine *Machine) { @@ -632,7 +632,7 @@ static void WriteAsOperandInternal(std::ostream &Out, const Type *T, /// the whole instruction that generated it. /// std::ostream &llvm::WriteAsOperand(std::ostream &Out, const Type *Ty, - bool PrintType, bool PrintName, + bool PrintType, bool PrintName, const Module *Context) { std::map<const Type *, std::string> TypeNames; assert(Context != 0 && "Can't write types as operand without module context"); @@ -641,7 +641,7 @@ std::ostream &llvm::WriteAsOperand(std::ostream &Out, const Type *Ty, // if (PrintType) // printTypeInt(Out, V->getType(), TypeNames); - + printTypeInt(Out, Ty, TypeNames); WriteAsOperandInternal(Out, Ty, PrintName, TypeNames, 0); @@ -753,7 +753,7 @@ std::ostream &AssemblyWriter::printTypeAtLeastOneLevel(const Type *Ty) { } -void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType, +void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType, bool PrintName) { if (Operand != 0) { if (PrintType) { Out << ' '; printType(Operand->getType()); } @@ -766,7 +766,7 @@ void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType, void AssemblyWriter::printModule(const Module *M) { if (!M->getModuleIdentifier().empty() && - // Don't print the ID if it will start a new line (which would + // Don't print the ID if it will start a new line (which would // require a comment char before it). M->getModuleIdentifier().find('\n') == std::string::npos) Out << "; ModuleID = '" << M->getModuleIdentifier() << "'\n"; @@ -783,7 +783,7 @@ void AssemblyWriter::printModule(const Module *M) { } if (!M->getTargetTriple().empty()) Out << "target triple = \"" << M->getTargetTriple() << "\"\n"; - + // Loop over the dependent libraries and emit them. Module::lib_iterator LI = M->lib_begin(); Module::lib_iterator LE = M->lib_end(); @@ -800,12 +800,12 @@ void AssemblyWriter::printModule(const Module *M) { // Loop over the symbol table, emitting all named constants. printSymbolTable(M->getSymbolTable()); - + for (Module::const_global_iterator I = M->global_begin(), E = M->global_end(); I != E; ++I) printGlobal(I); Out << "\nimplementation ; Functions:\n"; - + // Output all of the functions. for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) printFunction(I); @@ -814,7 +814,7 @@ void AssemblyWriter::printModule(const Module *M) { void AssemblyWriter::printGlobal(const GlobalVariable *GV) { if (GV->hasName()) Out << getLLVMName(GV->getName()) << " = "; - if (!GV->hasInitializer()) + if (!GV->hasInitializer()) Out << "external "; else switch (GV->getLinkage()) { @@ -856,7 +856,7 @@ void AssemblyWriter::printSymbolTable(const SymbolTable &ST) { // printTypeAtLeastOneLevel(TI->second) << "\n"; } - + // Print the constants, in type plane order. for (SymbolTable::plane_const_iterator PI = ST.plane_begin(); PI != ST.plane_end(); ++PI ) { @@ -940,7 +940,7 @@ void AssemblyWriter::printFunction(const Function *F) { Out << "\n"; } else { Out << " {"; - + // Output all of its basic blocks... for the function for (Function::const_iterator I = F->begin(), E = F->end(); I != E; ++I) printBasicBlock(I); @@ -960,7 +960,7 @@ void AssemblyWriter::printArgument(const Argument *Arg) { // Output type... printType(Arg->getType()); - + // Output name, if available... if (Arg->hasName()) Out << ' ' << getLLVMName(Arg->getName()); @@ -987,7 +987,7 @@ void AssemblyWriter::printBasicBlock(const BasicBlock *BB) { // Output predecessors for the block... Out << "\t\t;"; pred_const_iterator PI = pred_begin(BB), PE = pred_end(BB); - + if (PI == PE) { Out << " No predecessors!"; } else { @@ -1000,7 +1000,7 @@ void AssemblyWriter::printBasicBlock(const BasicBlock *BB) { } } } - + Out << "\n"; if (AnnotationWriter) AnnotationWriter->emitBasicBlockStartAnnot(BB, Out); @@ -1080,7 +1080,7 @@ void AssemblyWriter::printInstruction(const Instruction &I) { for (unsigned op = 0, Eop = I.getNumOperands(); op < Eop; op += 2) { if (op) Out << ", "; - Out << '['; + Out << '['; writeOperand(I.getOperand(op ), false); Out << ','; writeOperand(I.getOperand(op+1), false); Out << " ]"; } @@ -1096,7 +1096,7 @@ void AssemblyWriter::printInstruction(const Instruction &I) { // and if the return type is not a pointer to a function. // if (!FTy->isVarArg() && - (!isa<PointerType>(RetTy) || + (!isa<PointerType>(RetTy) || !isa<FunctionType>(cast<PointerType>(RetTy)->getElementType()))) { Out << ' '; printType(RetTy); writeOperand(Operand, false); @@ -1121,7 +1121,7 @@ void AssemblyWriter::printInstruction(const Instruction &I) { // and if the return type is not a pointer to a function. // if (!FTy->isVarArg() && - (!isa<PointerType>(RetTy) || + (!isa<PointerType>(RetTy) || !isa<FunctionType>(cast<PointerType>(RetTy)->getElementType()))) { Out << ' '; printType(RetTy); writeOperand(Operand, false); @@ -1162,7 +1162,7 @@ void AssemblyWriter::printInstruction(const Instruction &I) { printType(VAN->getArgType()); } else if (Operand) { // Print the normal way... - // PrintAllTypes - Instructions who have operands of all the same type + // PrintAllTypes - Instructions who have operands of all the same type // omit the type from all but the first operand. If the instruction has // different type operands (for example br), then they are all printed. bool PrintAllTypes = false; @@ -1181,7 +1181,7 @@ void AssemblyWriter::printInstruction(const Instruction &I) { } } } - + if (!PrintAllTypes) { Out << ' '; printType(TheType); @@ -1223,7 +1223,7 @@ void Function::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { void BasicBlock::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { SlotMachine SlotTable(getParent()); - AssemblyWriter W(o, SlotTable, + AssemblyWriter W(o, SlotTable, getParent() ? getParent()->getParent() : 0, AAW); W.write(this); } @@ -1245,7 +1245,7 @@ void Constant::print(std::ostream &o) const { WriteConstantInt(o, this, false, TypeTable, 0); } -void Type::print(std::ostream &o) const { +void Type::print(std::ostream &o) const { if (this == 0) o << "<null Type>"; else @@ -1294,7 +1294,7 @@ CachedWriter &CachedWriter::operator<<(const Value &V) { AW->write(F); else if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(&V)) AW->write(GV); - else + else AW->writeOperand(&V, true, true); return *this; } @@ -1321,7 +1321,7 @@ CachedWriter& CachedWriter::operator<<(const Type &Ty) { // Module level constructor. Causes the contents of the Module (sans functions) // to be added to the slot table. -SlotMachine::SlotMachine(const Module *M) +SlotMachine::SlotMachine(const Module *M) : TheModule(M) ///< Saved for lazy initialization. , TheFunction(0) , FunctionProcessed(false) @@ -1334,7 +1334,7 @@ SlotMachine::SlotMachine(const Module *M) // Function level constructor. Causes the contents of the Module and the one // function provided to be added to the slot table. -SlotMachine::SlotMachine(const Function *F ) +SlotMachine::SlotMachine(const Function *F ) : TheModule( F ? F->getParent() : 0 ) ///< Saved for lazy initialization , TheFunction(F) ///< Saved for lazy initialization , FunctionProcessed(false) @@ -1346,17 +1346,17 @@ SlotMachine::SlotMachine(const Function *F ) } inline void SlotMachine::initialize(void) { - if ( TheModule) { - processModule(); + if ( TheModule) { + processModule(); TheModule = 0; ///< Prevent re-processing next time we're called. } - if ( TheFunction && ! FunctionProcessed) { - processFunction(); + if ( TheFunction && ! FunctionProcessed) { + processFunction(); } } // Iterate through all the global variables, functions, and global -// variable initializers and create slots for them. +// variable initializers and create slots for them. void SlotMachine::processModule() { SC_DEBUG("begin processModule!\n"); @@ -1379,14 +1379,14 @@ void SlotMachine::processFunction() { SC_DEBUG("begin processFunction!\n"); // Add all the function arguments - for(Function::const_arg_iterator AI = TheFunction->arg_begin(), + for(Function::const_arg_iterator AI = TheFunction->arg_begin(), AE = TheFunction->arg_end(); AI != AE; ++AI) createSlot(AI); SC_DEBUG("Inserting Instructions:\n"); // Add all of the basic blocks and instructions - for (Function::const_iterator BB = TheFunction->begin(), + for (Function::const_iterator BB = TheFunction->begin(), E = TheFunction->end(); BB != E; ++BB) { createSlot(BB); for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E; ++I) { @@ -1417,8 +1417,8 @@ void SlotMachine::purgeFunction() { /// Types are forbidden because Type does not inherit from Value (any more). int SlotMachine::getSlot(const Value *V) { assert( V && "Can't get slot for null Value" ); - assert(!isa<Constant>(V) || isa<GlobalValue>(V) && - "Can't insert a non-GlobalValue Constant into SlotMachine"); + assert(!isa<Constant>(V) || isa<GlobalValue>(V) && + "Can't insert a non-GlobalValue Constant into SlotMachine"); // Check for uninitialized state and do lazy initialization this->initialize(); @@ -1445,7 +1445,7 @@ int SlotMachine::getSlot(const Value *V) { if (MVI == MI->second.map.end()) return -1; assert( MVI != MI->second.map.end() && "Value not found"); // We found it only at the module level - return MVI->second; + return MVI->second; // else the value exists in the function map } else { @@ -1489,10 +1489,10 @@ int SlotMachine::getSlot(const Type *Ty) { if ( FTI == fTypes.map.end() ) { TypeMap::const_iterator MTI = mTypes.map.find(Ty); // If we didn't find it, it wasn't inserted - if (MTI == mTypes.map.end()) + if (MTI == mTypes.map.end()) return -1; // We found it only at the module level - return MTI->second; + return MTI->second; // else the value exists in the function map } else { @@ -1518,8 +1518,8 @@ int SlotMachine::getSlot(const Type *Ty) { // of asserting when the Value* isn't found, it inserts the value. unsigned SlotMachine::createSlot(const Value *V) { assert( V && "Can't insert a null Value to SlotMachine"); - assert(!isa<Constant>(V) || isa<GlobalValue>(V) && - "Can't insert a non-GlobalValue Constant into SlotMachine"); + assert(!isa<Constant>(V) || isa<GlobalValue>(V) && + "Can't insert a non-GlobalValue Constant into SlotMachine"); const Type* VTy = V->getType(); @@ -1587,7 +1587,7 @@ unsigned SlotMachine::createSlot(const Value *V) { if ( MI != mMap.end() ) { // Lookup the value in the module's map ValueMap::const_iterator MVI = MI->second.map.find(V); - if ( MVI != MI->second.map.end() ) + if ( MVI != MI->second.map.end() ) return MVI->second; } @@ -1627,7 +1627,7 @@ unsigned SlotMachine::createSlot(const Type *Ty) { // Lookup the type in the module's map TypeMap::const_iterator MTI = mTypes.map.find(Ty); - if ( MTI != mTypes.map.end() ) + if ( MTI != mTypes.map.end() ) return MTI->second; return insertValue(Ty); @@ -1637,11 +1637,11 @@ unsigned SlotMachine::createSlot(const Type *Ty) { // function is just for the convenience of createSlot (above). unsigned SlotMachine::insertValue(const Value *V ) { assert(V && "Can't insert a null Value into SlotMachine!"); - assert(!isa<Constant>(V) || isa<GlobalValue>(V) && - "Can't insert a non-GlobalValue Constant into SlotMachine"); + assert(!isa<Constant>(V) || isa<GlobalValue>(V) && + "Can't insert a non-GlobalValue Constant into SlotMachine"); // If this value does not contribute to a plane (is void) - // or if the value already has a name then ignore it. + // or if the value already has a name then ignore it. if (V->getType() == Type::VoidTy || V->hasName() ) { SC_DEBUG("ignored value " << *V << "\n"); return 0; // FIXME: Wrong return value @@ -1652,7 +1652,7 @@ unsigned SlotMachine::insertValue(const Value *V ) { if ( TheFunction ) { TypedPlanes::iterator I = fMap.find( VTy ); - if ( I == fMap.end() ) + if ( I == fMap.end() ) I = fMap.insert(std::make_pair(VTy,ValuePlane())).first; DestSlot = I->second.map[V] = I->second.next_slot++; } else { @@ -1662,10 +1662,10 @@ unsigned SlotMachine::insertValue(const Value *V ) { DestSlot = I->second.map[V] = I->second.next_slot++; } - SC_DEBUG(" Inserting value [" << VTy << "] = " << V << " slot=" << + SC_DEBUG(" Inserting value [" << VTy << "] = " << V << " slot=" << DestSlot << " ["); // G = Global, C = Constant, T = Type, F = Function, o = other - SC_DEBUG((isa<GlobalVariable>(V) ? 'G' : (isa<Function>(V) ? 'F' : + SC_DEBUG((isa<GlobalVariable>(V) ? 'G' : (isa<Function>(V) ? 'F' : (isa<Constant>(V) ? 'C' : 'o')))); SC_DEBUG("]\n"); return DestSlot; diff --git a/lib/VMCore/BasicBlock.cpp b/lib/VMCore/BasicBlock.cpp index 1d70b00..a9fb924 100644 --- a/lib/VMCore/BasicBlock.cpp +++ b/lib/VMCore/BasicBlock.cpp @@ -1,10 +1,10 @@ //===-- BasicBlock.cpp - Implement BasicBlock related methods -------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements the BasicBlock class for the VMCore library. @@ -130,7 +130,7 @@ BasicBlock *BasicBlock::getSinglePredecessor() { /// removePredecessor - This method is used to notify a BasicBlock that the /// specified Predecessor of the block is no longer able to reach it. This is -/// actually not used to update the Predecessor list, but is actually used to +/// actually not used to update the Predecessor list, but is actually used to /// update the PHI nodes that reside in the block. Note that this should be /// called while the predecessor still refers to this block. /// @@ -153,9 +153,9 @@ void BasicBlock::removePredecessor(BasicBlock *Pred, // br Loop ;; %x2 does not dominate all uses // // This is because the PHI node input is actually taken from the predecessor - // basic block. The only case this can happen is with a self loop, so we + // basic block. The only case this can happen is with a self loop, so we // check for this case explicitly now. - // + // unsigned max_idx = APN->getNumIncomingValues(); assert(max_idx != 0 && "PHI Node in block with 0 predecessors!?!?!"); if (max_idx == 2) { @@ -197,18 +197,18 @@ void BasicBlock::removePredecessor(BasicBlock *Pred, /// splitBasicBlock - This splits a basic block into two at the specified /// instruction. Note that all instructions BEFORE the specified iterator stay -/// as part of the original basic block, an unconditional branch is added to +/// as part of the original basic block, an unconditional branch is added to /// the new BB, and the rest of the instructions in the BB are moved to the new /// BB, including the old terminator. This invalidates the iterator. /// -/// Note that this only works on well formed basic blocks (must have a +/// Note that this only works on well formed basic blocks (must have a /// terminator), and 'I' must not be the end of instruction list (which would /// cause a degenerate basic block to be formed, having a terminator inside of -/// the basic block). +/// the basic block). /// BasicBlock *BasicBlock::splitBasicBlock(iterator I, const std::string &BBName) { assert(getTerminator() && "Can't use splitBasicBlock on degenerate BB!"); - assert(I != InstList.end() && + assert(I != InstList.end() && "Trying to get me to create degenerate basic block!"); BasicBlock *New = new BasicBlock(BBName, getParent(), getNext()); diff --git a/lib/VMCore/ConstantFold.cpp b/lib/VMCore/ConstantFold.cpp index 772b79a..9ca8de3 100644 --- a/lib/VMCore/ConstantFold.cpp +++ b/lib/VMCore/ConstantFold.cpp @@ -1,10 +1,10 @@ //===- ConstantFolding.cpp - LLVM constant folder -------------------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements folding of constants for LLVM. This implements the @@ -30,7 +30,7 @@ using namespace llvm; namespace { struct ConstRules { ConstRules() {} - + // Binary Operators... virtual Constant *add(const Constant *V1, const Constant *V2) const = 0; virtual Constant *sub(const Constant *V1, const Constant *V2) const = 0; @@ -59,7 +59,7 @@ namespace { virtual Constant *castToDouble(const Constant *V) const = 0; virtual Constant *castToPointer(const Constant *V, const PointerType *Ty) const = 0; - + // ConstRules::get - Return an instance of ConstRules for the specified // constant operands. // @@ -75,11 +75,11 @@ namespace { // TemplateRules Class //===----------------------------------------------------------------------===// // -// TemplateRules - Implement a subclass of ConstRules that provides all -// operations as noops. All other rules classes inherit from this class so -// that if functionality is needed in the future, it can simply be added here +// TemplateRules - Implement a subclass of ConstRules that provides all +// operations as noops. All other rules classes inherit from this class so +// that if functionality is needed in the future, it can simply be added here // and to ConstRules without changing anything else... -// +// // This class also provides subclasses with typesafe implementations of methods // so that don't have to do type casting. // @@ -90,41 +90,41 @@ class TemplateRules : public ConstRules { // Redirecting functions that cast to the appropriate types //===--------------------------------------------------------------------===// - virtual Constant *add(const Constant *V1, const Constant *V2) const { - return SubClassName::Add((const ArgType *)V1, (const ArgType *)V2); + virtual Constant *add(const Constant *V1, const Constant *V2) const { + return SubClassName::Add((const ArgType *)V1, (const ArgType *)V2); } - virtual Constant *sub(const Constant *V1, const Constant *V2) const { - return SubClassName::Sub((const ArgType *)V1, (const ArgType *)V2); + virtual Constant *sub(const Constant *V1, const Constant *V2) const { + return SubClassName::Sub((const ArgType *)V1, (const ArgType *)V2); } - virtual Constant *mul(const Constant *V1, const Constant *V2) const { - return SubClassName::Mul((const ArgType *)V1, (const ArgType *)V2); + virtual Constant *mul(const Constant *V1, const Constant *V2) const { + return SubClassName::Mul((const ArgType *)V1, (const ArgType *)V2); } - virtual Constant *div(const Constant *V1, const Constant *V2) const { - return SubClassName::Div((const ArgType *)V1, (const ArgType *)V2); + virtual Constant *div(const Constant *V1, const Constant *V2) const { + return SubClassName::Div((const ArgType *)V1, (const ArgType *)V2); } - virtual Constant *rem(const Constant *V1, const Constant *V2) const { - return SubClassName::Rem((const ArgType *)V1, (const ArgType *)V2); + virtual Constant *rem(const Constant *V1, const Constant *V2) const { + return SubClassName::Rem((const ArgType *)V1, (const ArgType *)V2); } - virtual Constant *op_and(const Constant *V1, const Constant *V2) const { - return SubClassName::And((const ArgType *)V1, (const ArgType *)V2); + virtual Constant *op_and(const Constant *V1, const Constant *V2) const { + return SubClassName::And((const ArgType *)V1, (const ArgType *)V2); } - virtual Constant *op_or(const Constant *V1, const Constant *V2) const { - return SubClassName::Or((const ArgType *)V1, (const ArgType *)V2); + virtual Constant *op_or(const Constant *V1, const Constant *V2) const { + return SubClassName::Or((const ArgType *)V1, (const ArgType *)V2); } - virtual Constant *op_xor(const Constant *V1, const Constant *V2) const { - return SubClassName::Xor((const ArgType *)V1, (const ArgType *)V2); + virtual Constant *op_xor(const Constant *V1, const Constant *V2) const { + return SubClassName::Xor((const ArgType *)V1, (const ArgType *)V2); } - virtual Constant *shl(const Constant *V1, const Constant *V2) const { - return SubClassName::Shl((const ArgType *)V1, (const ArgType *)V2); + virtual Constant *shl(const Constant *V1, const Constant *V2) const { + return SubClassName::Shl((const ArgType *)V1, (const ArgType *)V2); } - virtual Constant *shr(const Constant *V1, const Constant *V2) const { - return SubClassName::Shr((const ArgType *)V1, (const ArgType *)V2); + virtual Constant *shr(const Constant *V1, const Constant *V2) const { + return SubClassName::Shr((const ArgType *)V1, (const ArgType *)V2); } - virtual Constant *lessthan(const Constant *V1, const Constant *V2) const { + virtual Constant *lessthan(const Constant *V1, const Constant *V2) const { return SubClassName::LessThan((const ArgType *)V1, (const ArgType *)V2); } - virtual Constant *equalto(const Constant *V1, const Constant *V2) const { + virtual Constant *equalto(const Constant *V1, const Constant *V2) const { return SubClassName::EqualTo((const ArgType *)V1, (const ArgType *)V2); } @@ -162,7 +162,7 @@ class TemplateRules : public ConstRules { virtual Constant *castToDouble(const Constant *V) const { return SubClassName::CastToDouble((const ArgType*)V); } - virtual Constant *castToPointer(const Constant *V, + virtual Constant *castToPointer(const Constant *V, const PointerType *Ty) const { return SubClassName::CastToPointer((const ArgType*)V, Ty); } @@ -357,7 +357,7 @@ struct DirectRules : public TemplateRules<ConstantClass, SuperClass> { static Constant *LessThan(const ConstantClass *V1, const ConstantClass *V2) { bool R = (BuiltinType)V1->getValue() < (BuiltinType)V2->getValue(); return ConstantBool::get(R); - } + } static Constant *EqualTo(const ConstantClass *V1, const ConstantClass *V2) { bool R = (BuiltinType)V1->getValue() == (BuiltinType)V2->getValue(); @@ -654,7 +654,7 @@ static int IdxCompare(Constant *C1, Constant *C2, const Type *ElTy) { // ConstantExprs? If so, we can't do anything with them. if (!isa<ConstantInt>(C1) || !isa<ConstantInt>(C2)) return -2; // don't know! - + // Ok, we have two differing integer indices. Sign extend them to be the same // type. Long is always big enough, so we use it. C1 = ConstantExpr::getSignExtend(C1, Type::LongTy); @@ -798,7 +798,7 @@ static Instruction::BinaryOps evaluateRelation(const Constant *V1, // same global. From this, we can precisely determine the relative // ordering of the resultant pointers. unsigned i = 1; - + // Compare all of the operands the GEP's have in common. gep_type_iterator GTI = gep_type_begin(CE1); for (;i != CE1->getNumOperands() && i != CE2->getNumOperands(); @@ -818,7 +818,7 @@ static Instruction::BinaryOps evaluateRelation(const Constant *V1, return Instruction::SetGT; else return Instruction::BinaryOpsEnd; // Might be equal. - + for (; i < CE2->getNumOperands(); ++i) if (!CE2->getOperand(i)->isNullValue()) if (isa<ConstantIntegral>(CE2->getOperand(i))) @@ -829,7 +829,7 @@ static Instruction::BinaryOps evaluateRelation(const Constant *V1, } } } - + default: break; } @@ -910,7 +910,7 @@ Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode, if (Opcode == Instruction::SetLT) return ConstantBool::False; if (Opcode == Instruction::SetGT) return ConstantBool::True; break; - + case Instruction::SetNE: // If we know that V1 != V2, we can only partially decide this relation. if (Opcode == Instruction::SetEQ) return ConstantBool::False; @@ -1115,12 +1115,12 @@ Constant *llvm::ConstantFoldGetElementPtr(const Constant *C, if (!Idx0->isNullValue()) { const Type *IdxTy = Combined->getType(); if (IdxTy != Idx0->getType()) IdxTy = Type::LongTy; - Combined = + Combined = ConstantExpr::get(Instruction::Add, ConstantExpr::getCast(Idx0, IdxTy), ConstantExpr::getCast(Combined, IdxTy)); } - + NewIndices.push_back(Combined); NewIndices.insert(NewIndices.end(), IdxList.begin()+1, IdxList.end()); return ConstantExpr::getGetElementPtr(CE->getOperand(0), NewIndices); @@ -1134,7 +1134,7 @@ Constant *llvm::ConstantFoldGetElementPtr(const Constant *C, // if (CE->getOpcode() == Instruction::Cast && IdxList.size() > 1 && Idx0->isNullValue()) - if (const PointerType *SPT = + if (const PointerType *SPT = dyn_cast<PointerType>(CE->getOperand(0)->getType())) if (const ArrayType *SAT = dyn_cast<ArrayType>(SPT->getElementType())) if (const ArrayType *CAT = diff --git a/lib/VMCore/ConstantFold.h b/lib/VMCore/ConstantFold.h index 84e358c..a864aa2 100644 --- a/lib/VMCore/ConstantFold.h +++ b/lib/VMCore/ConstantFold.h @@ -1,10 +1,10 @@ //===-- ConstantFolding.h - Internal Constant Folding Interface -*- C++ -*-===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file defines the (internal) constant folding interfaces for LLVM. These @@ -25,7 +25,7 @@ namespace llvm { class Value; class Constant; class Type; - + // Constant fold various types of instruction... Constant *ConstantFoldCastInstruction(const Constant *V, const Type *DestTy); Constant *ConstantFoldSelectInstruction(const Constant *Cond, diff --git a/lib/VMCore/ConstantFolding.h b/lib/VMCore/ConstantFolding.h index 84e358c..a864aa2 100644 --- a/lib/VMCore/ConstantFolding.h +++ b/lib/VMCore/ConstantFolding.h @@ -1,10 +1,10 @@ //===-- ConstantFolding.h - Internal Constant Folding Interface -*- C++ -*-===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file defines the (internal) constant folding interfaces for LLVM. These @@ -25,7 +25,7 @@ namespace llvm { class Value; class Constant; class Type; - + // Constant fold various types of instruction... Constant *ConstantFoldCastInstruction(const Constant *V, const Type *DestTy); Constant *ConstantFoldSelectInstruction(const Constant *Cond, diff --git a/lib/VMCore/ConstantRange.cpp b/lib/VMCore/ConstantRange.cpp index 3b91c5b..109ed42 100644 --- a/lib/VMCore/ConstantRange.cpp +++ b/lib/VMCore/ConstantRange.cpp @@ -1,10 +1,10 @@ //===-- ConstantRange.cpp - ConstantRange implementation ------------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // Represent a range of possible values that may occur when the program is run @@ -32,7 +32,7 @@ using namespace llvm; static ConstantIntegral *Next(ConstantIntegral *CI) { if (CI->getType() == Type::BoolTy) return CI == ConstantBool::True ? ConstantBool::False : ConstantBool::True; - + Constant *Result = ConstantExpr::getAdd(CI, ConstantInt::get(CI->getType(), 1)); return cast<ConstantIntegral>(Result); @@ -84,7 +84,7 @@ ConstantRange::ConstantRange(Constant *L, Constant *U) : Lower(cast<ConstantIntegral>(L)), Upper(cast<ConstantIntegral>(U)) { assert(Lower->getType() == Upper->getType() && "Incompatible types for ConstantRange!"); - + // Make sure that if L & U are equal that they are either Min or Max... assert((L != U || (L == ConstantIntegral::getMaxValue(L->getType()) || L == ConstantIntegral::getMinValue(L->getType()))) && @@ -126,7 +126,7 @@ const Type *ConstantRange::getType() const { return Lower->getType(); } bool ConstantRange::isFullSet() const { return Lower == Upper && Lower == ConstantIntegral::getMaxValue(getType()); } - + /// isEmptySet - Return true if this set contains no members. /// bool ConstantRange::isEmptySet() const { @@ -140,7 +140,7 @@ bool ConstantRange::isWrappedSet() const { return GT(Lower, Upper); } - + /// getSingleElement - If this set contains a single element, return it, /// otherwise return null. ConstantIntegral *ConstantRange::getSingleElement() const { @@ -158,7 +158,7 @@ uint64_t ConstantRange::getSetSize() const { return 1; return 2; // Must be full set... } - + // Simply subtract the bounds... Constant *Result = ConstantExpr::getSub(Upper, Lower); return cast<ConstantInt>(Result)->getRawValue(); diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp index ee60f80..2bedef5 100644 --- a/lib/VMCore/Constants.cpp +++ b/lib/VMCore/Constants.cpp @@ -1,10 +1,10 @@ //===-- Constants.cpp - Implement Constant nodes --------------------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements the Constant* classes... @@ -108,7 +108,7 @@ Constant *Constant::getNullValue(const Type *Ty) { return NullDouble; } - case Type::PointerTyID: + case Type::PointerTyID: return ConstantPointerNull::get(cast<PointerType>(Ty)); case Type::StructTyID: @@ -130,7 +130,7 @@ ConstantIntegral *ConstantIntegral::getMaxValue(const Type *Ty) { case Type::ShortTyID: case Type::IntTyID: case Type::LongTyID: { - // Calculate 011111111111111... + // Calculate 011111111111111... unsigned TypeBits = Ty->getPrimitiveSize()*8; int64_t Val = INT64_MAX; // All ones Val >>= 64-TypeBits; // Shift out unwanted 1 bits... @@ -154,7 +154,7 @@ ConstantIntegral *ConstantIntegral::getMinValue(const Type *Ty) { case Type::ShortTyID: case Type::IntTyID: case Type::LongTyID: { - // Calculate 1111111111000000000000 + // Calculate 1111111111000000000000 unsigned TypeBits = Ty->getPrimitiveSize()*8; int64_t Val = -1; // All ones Val <<= TypeBits-1; // Shift over to the right spot @@ -347,7 +347,7 @@ struct GetElementPtrConstantExpr : public ConstantExpr { OperandList[i+1].init(IdxList[i], this); } ~GetElementPtrConstantExpr() { - delete [] OperandList; + delete [] OperandList; } }; @@ -489,7 +489,7 @@ void ConstantArray::replaceUsesOfWithOnConstant(Value *From, Value *To, if (Val == From) Val = cast<Constant>(To); Values.push_back(Val); } - + Constant *Replacement = ConstantArray::get(getType(), Values); assert(Replacement != this && "I didn't contain From!"); @@ -498,9 +498,9 @@ void ConstantArray::replaceUsesOfWithOnConstant(Value *From, Value *To, uncheckedReplaceAllUsesWith(Replacement); else replaceAllUsesWith(Replacement); - + // Delete the old constant! - destroyConstant(); + destroyConstant(); } void ConstantStruct::replaceUsesOfWithOnConstant(Value *From, Value *To, @@ -514,7 +514,7 @@ void ConstantStruct::replaceUsesOfWithOnConstant(Value *From, Value *To, if (Val == From) Val = cast<Constant>(To); Values.push_back(Val); } - + Constant *Replacement = ConstantStruct::get(getType(), Values); assert(Replacement != this && "I didn't contain From!"); @@ -523,7 +523,7 @@ void ConstantStruct::replaceUsesOfWithOnConstant(Value *From, Value *To, uncheckedReplaceAllUsesWith(Replacement); else replaceAllUsesWith(Replacement); - + // Delete the old constant! destroyConstant(); } @@ -539,7 +539,7 @@ void ConstantPacked::replaceUsesOfWithOnConstant(Value *From, Value *To, if (Val == From) Val = cast<Constant>(To); Values.push_back(Val); } - + Constant *Replacement = ConstantPacked::get(getType(), Values); assert(Replacement != this && "I didn't contain From!"); @@ -548,9 +548,9 @@ void ConstantPacked::replaceUsesOfWithOnConstant(Value *From, Value *To, uncheckedReplaceAllUsesWith(Replacement); else replaceAllUsesWith(Replacement); - + // Delete the old constant! - destroyConstant(); + destroyConstant(); } void ConstantExpr::replaceUsesOfWithOnConstant(Value *From, Value *ToV, @@ -564,7 +564,7 @@ void ConstantExpr::replaceUsesOfWithOnConstant(Value *From, Value *ToV, Constant *Pointer = getOperand(0); Indices.reserve(getNumOperands()-1); if (Pointer == From) Pointer = To; - + for (unsigned i = 1, e = getNumOperands(); i != e; ++i) { Constant *Val = getOperand(i); if (Val == From) Val = To; @@ -592,7 +592,7 @@ void ConstantExpr::replaceUsesOfWithOnConstant(Value *From, Value *ToV, assert(0 && "Unknown ConstantExpr type!"); return; } - + assert(Replacement != this && "I didn't contain From!"); // Everyone using this now uses the replacement... @@ -600,7 +600,7 @@ void ConstantExpr::replaceUsesOfWithOnConstant(Value *From, Value *ToV, uncheckedReplaceAllUsesWith(Replacement); else replaceAllUsesWith(Replacement); - + // Delete the old constant! destroyConstant(); } @@ -620,7 +620,7 @@ namespace llvm { return new ConstantClass(Ty, V); } }; - + template<class ConstantClass, class TypeClass> struct ConvertConstantType { static void convert(ConstantClass *OldC, const TypeClass *NewTy) { @@ -683,7 +683,7 @@ namespace { } return Result; } - + void remove(ConstantClass *CP) { MapIterator I = Map.find(MapKey((TypeClass*)CP->getRawType(), getValType(CP))); @@ -708,14 +708,14 @@ namespace { // Yes, we are removing the representative entry for this type. // See if there are any other entries of the same type. MapIterator TmpIt = ATMEntryIt; - + // First check the entry before this one... if (TmpIt != Map.begin()) { --TmpIt; if (TmpIt->first.first != Ty) // Not the same type, move back... ++TmpIt; } - + // If we didn't find the same type, try to move forward... if (TmpIt == ATMEntryIt) { ++TmpIt; @@ -735,12 +735,12 @@ namespace { } } } - + Map.erase(I); } void refineAbstractType(const DerivedType *OldTy, const Type *NewTy) { - typename AbstractTypeMapTy::iterator I = + typename AbstractTypeMapTy::iterator I = AbstractTypeMap.find(cast<TypeClass>(OldTy)); assert(I != AbstractTypeMap.end() && @@ -995,14 +995,14 @@ namespace llvm { C.push_back(cast<Constant>(OldC->getOperand(i))); Constant *New = ConstantStruct::get(NewTy, C); assert(New != OldC && "Didn't replace constant??"); - + OldC->uncheckedReplaceAllUsesWith(New); OldC->destroyConstant(); // This constant is now dead, destroy it. } }; } -static ValueMap<std::vector<Constant*>, StructType, +static ValueMap<std::vector<Constant*>, StructType, ConstantStruct> StructConstants; static std::vector<Constant*> getValType(ConstantStruct *CS) { @@ -1197,9 +1197,9 @@ namespace llvm { return new BinaryConstantExpr(V.first, V.second[0], V.second[1]); if (V.first == Instruction::Select) return new SelectConstantExpr(V.second[0], V.second[1], V.second[2]); - + assert(V.first == Instruction::GetElementPtr && "Invalid ConstantExpr!"); - + std::vector<Constant*> IdxList(V.second.begin()+1, V.second.end()); return new GetElementPtrConstantExpr(V.second[0], IdxList, Ty); } @@ -1230,12 +1230,12 @@ namespace llvm { OldC->getOperand(1)); break; case Instruction::GetElementPtr: - // Make everyone now use a constant of the new type... + // Make everyone now use a constant of the new type... std::vector<Value*> Idx(OldC->op_begin()+1, OldC->op_end()); New = ConstantExpr::getGetElementPtrTy(NewTy, OldC->getOperand(0), Idx); break; } - + assert(New != OldC && "Didn't replace constant??"); OldC->uncheckedReplaceAllUsesWith(New); OldC->destroyConstant(); // This constant is now dead, destroy it. @@ -1333,7 +1333,7 @@ Constant *ConstantExpr::get(unsigned Opcode, Constant *C1, Constant *C2) { case Instruction::Mul: case Instruction::Div: case Instruction::Rem: assert(C1->getType() == C2->getType() && "Op types should be identical!"); - assert((C1->getType()->isInteger() || C1->getType()->isFloatingPoint()) && + assert((C1->getType()->isInteger() || C1->getType()->isFloatingPoint()) && "Tried to create an arithmetic operation on a non-arithmetic type!"); break; case Instruction::And: @@ -1471,7 +1471,7 @@ void Constant::clearAllValueMaps() { UndefValueConstants.clear(Constants); ExprConstants.clear(Constants); - for (std::vector<Constant *>::iterator I = Constants.begin(), + for (std::vector<Constant *>::iterator I = Constants.begin(), E = Constants.end(); I != E; ++I) (*I)->dropAllReferences(); for (std::vector<Constant *>::iterator I = Constants.begin(), diff --git a/lib/VMCore/Dominators.cpp b/lib/VMCore/Dominators.cpp index b70c7b5..220c7d9 100644 --- a/lib/VMCore/Dominators.cpp +++ b/lib/VMCore/Dominators.cpp @@ -1,10 +1,10 @@ //===- Dominators.cpp - Dominator Calculation -----------------------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements simple dominator construction algorithms for finding @@ -74,7 +74,7 @@ void ImmediateDominators::Compress(BasicBlock *V, InfoRec &VInfo) { Compress(VAncestor, VAInfo); - BasicBlock *VAncestorLabel = VAInfo.Label; + BasicBlock *VAncestorLabel = VAInfo.Label; BasicBlock *VLabel = VInfo.Label; if (Info[VAncestorLabel].Semi < Info[VLabel].Semi) VInfo.Label = VAncestorLabel; @@ -115,10 +115,10 @@ void ImmediateDominators::Link(BasicBlock *V, BasicBlock *W, InfoRec &WInfo){ unsigned WLabelSemi = Info[WLabel].Semi; BasicBlock *S = W; InfoRec *SInfo = &Info[S]; - + BasicBlock *SChild = SInfo->Child; InfoRec *SChildInfo = &Info[SChild]; - + while (WLabelSemi < Info[SChildInfo->Label].Semi) { BasicBlock *SChildChild = SChildInfo->Child; if (SInfo->Size+Info[SChildChild].Size >= 2*SChildInfo->Size) { @@ -133,17 +133,17 @@ void ImmediateDominators::Link(BasicBlock *V, BasicBlock *W, InfoRec &WInfo){ SChildInfo = &Info[SChild]; } } - + InfoRec &VInfo = Info[V]; SInfo->Label = WLabel; - + assert(V != W && "The optimization here will not work in this case!"); unsigned WSize = WInfo.Size; unsigned VSize = (VInfo.Size += WSize); - + if (VSize < 2*WSize) std::swap(S, VInfo.Child); - + while (S) { SInfo = &Info[S]; SInfo->Ancestor = V; @@ -161,7 +161,7 @@ bool ImmediateDominators::runOnFunction(Function &F) { Roots.push_back(Root); Vertex.push_back(0); - + // Step #1: Number blocks in depth-first order and initialize variables used // in later stages of the algorithm. unsigned N = 0; @@ -179,7 +179,7 @@ bool ImmediateDominators::runOnFunction(Function &F) { if (SemiU < WInfo.Semi) WInfo.Semi = SemiU; } - + Info[Vertex[WInfo.Semi]].Bucket.push_back(W); BasicBlock *WParent = WInfo.Parent; @@ -240,11 +240,11 @@ B("domset", "Dominator Set Construction", true); bool DominatorSetBase::dominates(Instruction *A, Instruction *B) const { BasicBlock *BBA = A->getParent(), *BBB = B->getParent(); if (BBA != BBB) return dominates(BBA, BBB); - + // Loop through the basic block until we find A or B. BasicBlock::iterator I = BBA->begin(); for (; &*I != A && &*I != B; ++I) /*empty*/; - + // A dominates B if it is found first in the basic block... return &*I == A; } @@ -275,8 +275,8 @@ bool DominatorSet::runOnFunction(Function &F) { DomSetType &DS = Doms[I]; assert(DS.empty() && "Domset already filled in for this block?"); DS.insert(I); // Blocks always dominate themselves - - // Insert all dominators into the set... + + // Insert all dominators into the set... while (IDom) { // If we have already computed the dominator sets for our immediate // dominator, just use it instead of walking all the way up to the root. @@ -333,7 +333,7 @@ E("domtree", "Dominator Tree Construction", true); // DominatorTreeBase::reset - Free all of the tree node memory. // -void DominatorTreeBase::reset() { +void DominatorTreeBase::reset() { for (NodeMapType::iterator I = Nodes.begin(), E = Nodes.end(); I != E; ++I) delete I->second; Nodes.clear(); @@ -364,7 +364,7 @@ DominatorTreeBase::Node *DominatorTree::getNodeForBlock(BasicBlock *BB) { // immediate dominator. BasicBlock *IDom = getAnalysis<ImmediateDominators>()[BB]; Node *IDomNode = getNodeForBlock(IDom); - + // Add a new tree node for this BasicBlock, and link it as a child of // IDomNode return BBNode = IDomNode->addChild(new Node(BB, IDomNode)); @@ -403,7 +403,7 @@ static std::ostream &operator<<(std::ostream &o, static void PrintDomTree(const DominatorTreeBase::Node *N, std::ostream &o, unsigned Lev) { o << std::string(2*Lev, ' ') << "[" << Lev << "] " << N; - for (DominatorTreeBase::Node::const_iterator I = N->begin(), E = N->end(); + for (DominatorTreeBase::Node::const_iterator I = N->begin(), E = N->end(); I != E; ++I) PrintDomTree(*I, o, Lev+1); } @@ -423,7 +423,7 @@ static RegisterAnalysis<DominanceFrontier> G("domfrontier", "Dominance Frontier Construction", true); const DominanceFrontier::DomSetType & -DominanceFrontier::calculate(const DominatorTree &DT, +DominanceFrontier::calculate(const DominatorTree &DT, const DominatorTree::Node *Node) { // Loop over CFG successors to calculate DFlocal[Node] BasicBlock *BB = Node->getBlock(); diff --git a/lib/VMCore/Function.cpp b/lib/VMCore/Function.cpp index b883e07..2672e89 100644 --- a/lib/VMCore/Function.cpp +++ b/lib/VMCore/Function.cpp @@ -1,10 +1,10 @@ //===-- Function.cpp - Implement the Global object classes ----------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements the Function & GlobalVariable classes for the VMCore @@ -51,7 +51,7 @@ template class SymbolTableListTraits<BasicBlock, Function, Function>; // Argument Implementation //===----------------------------------------------------------------------===// -Argument::Argument(const Type *Ty, const std::string &Name, Function *Par) +Argument::Argument(const Type *Ty, const std::string &Name, Function *Par) : Value(Ty, Value::ArgumentVal, Name) { Parent = 0; @@ -125,7 +125,7 @@ bool Function::isVarArg() const { return getFunctionType()->isVarArg(); } -const Type *Function::getReturnType() const { +const Type *Function::getReturnType() const { return getFunctionType()->getReturnType(); } @@ -182,7 +182,7 @@ void Function::renameLocalSymbols() { // 'delete' a whole class at a time, even though there may be circular // references... first all references are dropped, and all use counts go to // zero. Then everything is deleted for real. Note that no operations are -// valid on an object that has "dropped all references", except operator +// valid on an object that has "dropped all references", except operator // delete. // void Function::dropAllReferences() { @@ -204,7 +204,7 @@ unsigned Function::getIntrinsicID() const { return 0; // All intrinsics start with 'llvm.' assert(getName().size() != 5 && "'llvm.' is an invalid intrinsic name!"); - + switch (getName()[5]) { case 'd': if (getName() == "llvm.dbg.stoppoint") return Intrinsic::dbg_stoppoint; @@ -233,8 +233,8 @@ unsigned Function::getIntrinsicID() const { if (getName() == "llvm.memset") return Intrinsic::memset; break; case 'p': - if (getName() == "llvm.prefetch") return Intrinsic::prefetch; - if (getName() == "llvm.pcmarker") return Intrinsic::pcmarker; + if (getName() == "llvm.prefetch") return Intrinsic::prefetch; + if (getName() == "llvm.pcmarker") return Intrinsic::pcmarker; break; case 'r': if (getName() == "llvm.returnaddress") return Intrinsic::returnaddress; diff --git a/lib/VMCore/Globals.cpp b/lib/VMCore/Globals.cpp index c0264ae..87eca2a 100644 --- a/lib/VMCore/Globals.cpp +++ b/lib/VMCore/Globals.cpp @@ -1,10 +1,10 @@ //===-- Globals.cpp - Implement the Global object classes -----------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements the GlobalValue & GlobalVariable classes for the VMCore @@ -23,7 +23,7 @@ using namespace llvm; // GlobalValue Class //===----------------------------------------------------------------------===// -/// This could be named "SafeToDestroyGlobalValue". It just makes sure that +/// This could be named "SafeToDestroyGlobalValue". It just makes sure that /// there are no non-constant uses of this GlobalValue. If there aren't then /// this and the transitive closure of the constants can be deleted. See the /// destructor for details. @@ -32,7 +32,7 @@ static bool removeDeadConstantUsers(Constant* C) { while (!C->use_empty()) if (Constant *User = dyn_cast<Constant>(C->use_back())) { - if (!removeDeadConstantUsers(User)) + if (!removeDeadConstantUsers(User)) return false; // Constant wasn't dead } else { return false; // Non-constant usage; @@ -47,7 +47,7 @@ static bool removeDeadConstantUsers(Constant* C) { /// that want to check to see if a global is unused, but don't want to deal /// with potentially dead constants hanging off of the globals. /// -/// This function returns true if the global value is now dead. If all +/// This function returns true if the global value is now dead. If all /// users of this global are not dead, this method may return false and /// leave some of them around. void GlobalValue::removeDeadConstantUsers() { @@ -61,7 +61,7 @@ void GlobalValue::removeDeadConstantUsers() { } } -/// Override destroyConstant to make sure it doesn't get called on +/// Override destroyConstant to make sure it doesn't get called on /// GlobalValue's because they shouldn't be treated like other constants. void GlobalValue::destroyConstant() { assert(0 && "You can't GV->destroyConstant()!"); @@ -111,7 +111,7 @@ void GlobalVariable::replaceUsesOfWithOnConstant(Value *From, Value *To, bool DisableChecking) { // If you call this, then you better know this GVar has a constant // initializer worth replacing. Enforce that here. - assert(getNumOperands() == 1 && + assert(getNumOperands() == 1 && "Attempt to replace uses of Constants on a GVar with no initializer"); // And, since you know it has an initializer, the From value better be @@ -122,7 +122,7 @@ void GlobalVariable::replaceUsesOfWithOnConstant(Value *From, Value *To, // And, you better have a constant for the replacement value assert(isa<Constant>(To) && "Attempt to replace GVar initializer with non-constant"); - + // Okay, preconditions out of the way, replace the constant initializer. this->setOperand(0, cast<Constant>(To)); } diff --git a/lib/VMCore/Instruction.cpp b/lib/VMCore/Instruction.cpp index 4ccbd74..2a48128 100644 --- a/lib/VMCore/Instruction.cpp +++ b/lib/VMCore/Instruction.cpp @@ -1,10 +1,10 @@ //===-- Instruction.cpp - Implement the Instruction class -----------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements the Instruction class for the VMCore library. @@ -74,7 +74,7 @@ const char *Instruction::getOpcodeName(unsigned OpCode) { case Invoke: return "invoke"; case Unwind: return "unwind"; case Unreachable: return "unreachable"; - + // Standard binary operators... case Add: return "add"; case Sub: return "sub"; @@ -94,7 +94,7 @@ const char *Instruction::getOpcodeName(unsigned OpCode) { case SetGT: return "setgt"; case SetEQ: return "seteq"; case SetNE: return "setne"; - + // Memory instructions... case Malloc: return "malloc"; case Free: return "free"; @@ -102,7 +102,7 @@ const char *Instruction::getOpcodeName(unsigned OpCode) { case Load: return "load"; case Store: return "store"; case GetElementPtr: return "getelementptr"; - + // Other instructions... case PHI: return "phi"; case Cast: return "cast"; @@ -115,7 +115,7 @@ const char *Instruction::getOpcodeName(unsigned OpCode) { default: return "<Invalid operator> "; } - + return 0; } @@ -172,7 +172,7 @@ bool Instruction::isCommutative(unsigned op) { switch (op) { case Add: case Mul: - case And: + case And: case Or: case Xor: case SetEQ: diff --git a/lib/VMCore/Instructions.cpp b/lib/VMCore/Instructions.cpp index d3f7665..c3eacdd 100644 --- a/lib/VMCore/Instructions.cpp +++ b/lib/VMCore/Instructions.cpp @@ -1,10 +1,10 @@ //===-- Instructions.cpp - Implement the LLVM instructions ----------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements all of the non-inline methods for the LLVM instruction @@ -25,7 +25,7 @@ using namespace llvm; //===----------------------------------------------------------------------===// TerminatorInst::TerminatorInst(Instruction::TermOps iType, - Use *Ops, unsigned NumOps, Instruction *IB) + Use *Ops, unsigned NumOps, Instruction *IB) : Instruction(Type::VoidTy, iType, Ops, NumOps, "", IB) { } @@ -104,7 +104,7 @@ void PHINode::resizeOperands(unsigned NumOps) { } else if (NumOps == NumOperands) { if (ReservedSpace == NumOps) return; } else { - return; + return; } ReservedSpace = NumOps; @@ -132,10 +132,10 @@ void CallInst::init(Value *Func, const std::vector<Value*> &Params) { Use *OL = OperandList = new Use[Params.size()+1]; OL[0].init(Func, this); - const FunctionType *FTy = + const FunctionType *FTy = cast<FunctionType>(cast<PointerType>(Func->getType())->getElementType()); - assert((Params.size() == FTy->getNumParams() || + assert((Params.size() == FTy->getNumParams() || (FTy->isVarArg() && Params.size() > FTy->getNumParams())) && "Calling a function with bad signature"); for (unsigned i = 0, e = Params.size(); i != e; ++i) @@ -148,8 +148,8 @@ void CallInst::init(Value *Func, Value *Actual1, Value *Actual2) { OL[0].init(Func, this); OL[1].init(Actual1, this); OL[2].init(Actual2, this); - - const FunctionType *FTy = + + const FunctionType *FTy = cast<FunctionType>(cast<PointerType>(Func->getType())->getElementType()); assert((FTy->getNumParams() == 2 || @@ -162,8 +162,8 @@ void CallInst::init(Value *Func, Value *Actual) { Use *OL = OperandList = new Use[2]; OL[0].init(Func, this); OL[1].init(Actual, this); - - const FunctionType *FTy = + + const FunctionType *FTy = cast<FunctionType>(cast<PointerType>(Func->getType())->getElementType()); assert((FTy->getNumParams() == 1 || @@ -175,23 +175,23 @@ void CallInst::init(Value *Func) { NumOperands = 1; Use *OL = OperandList = new Use[1]; OL[0].init(Func, this); - - const FunctionType *MTy = + + const FunctionType *MTy = cast<FunctionType>(cast<PointerType>(Func->getType())->getElementType()); assert(MTy->getNumParams() == 0 && "Calling a function with bad signature"); } -CallInst::CallInst(Value *Func, const std::vector<Value*> &Params, - const std::string &Name, Instruction *InsertBefore) +CallInst::CallInst(Value *Func, const std::vector<Value*> &Params, + const std::string &Name, Instruction *InsertBefore) : Instruction(cast<FunctionType>(cast<PointerType>(Func->getType()) ->getElementType())->getReturnType(), Instruction::Call, 0, 0, Name, InsertBefore) { init(Func, Params); } -CallInst::CallInst(Value *Func, const std::vector<Value*> &Params, - const std::string &Name, BasicBlock *InsertAtEnd) +CallInst::CallInst(Value *Func, const std::vector<Value*> &Params, + const std::string &Name, BasicBlock *InsertAtEnd) : Instruction(cast<FunctionType>(cast<PointerType>(Func->getType()) ->getElementType())->getReturnType(), Instruction::Call, 0, 0, Name, InsertAtEnd) { @@ -246,7 +246,7 @@ CallInst::CallInst(Value *Func, const std::string &Name, init(Func); } -CallInst::CallInst(const CallInst &CI) +CallInst::CallInst(const CallInst &CI) : Instruction(CI.getType(), Instruction::Call, new Use[CI.getNumOperands()], CI.getNumOperands()) { Use *OL = OperandList; @@ -271,13 +271,13 @@ void InvokeInst::init(Value *Fn, BasicBlock *IfNormal, BasicBlock *IfException, OL[0].init(Fn, this); OL[1].init(IfNormal, this); OL[2].init(IfException, this); - const FunctionType *FTy = + const FunctionType *FTy = cast<FunctionType>(cast<PointerType>(Fn->getType())->getElementType()); - - assert((Params.size() == FTy->getNumParams()) || + + assert((Params.size() == FTy->getNumParams()) || (FTy->isVarArg() && Params.size() > FTy->getNumParams()) && "Calling a function with bad signature"); - + for (unsigned i = 0, e = Params.size(); i != e; i++) OL[i+3].init(Params[i], this); } @@ -302,7 +302,7 @@ InvokeInst::InvokeInst(Value *Fn, BasicBlock *IfNormal, init(Fn, IfNormal, IfException, Params); } -InvokeInst::InvokeInst(const InvokeInst &II) +InvokeInst::InvokeInst(const InvokeInst &II) : TerminatorInst(II.getType(), Instruction::Invoke, new Use[II.getNumOperands()], II.getNumOperands()) { Use *OL = OperandList, *InOL = II.OperandList; @@ -327,7 +327,7 @@ void InvokeInst::setSuccessorV(unsigned idx, BasicBlock *B) { void ReturnInst::init(Value *retVal) { if (retVal && retVal->getType() != Type::VoidTy) { - assert(!isa<BasicBlock>(retVal) && + assert(!isa<BasicBlock>(retVal) && "Cannot return basic block. Probably using the incorrect ctor"); NumOperands = 1; RetVal.init(retVal, this); @@ -393,7 +393,7 @@ BasicBlock *UnreachableInst::getSuccessorV(unsigned idx) const { void BranchInst::AssertOK() { if (isConditional()) - assert(getCondition()->getType() == Type::BoolTy && + assert(getCondition()->getType() == Type::BoolTy && "May only branch on boolean predicates!"); } @@ -428,10 +428,10 @@ static Value *getAISize(Value *Amt) { else assert(Amt->getType() == Type::UIntTy && "Malloc/Allocation array size != UIntTy!"); - return Amt; + return Amt; } -AllocationInst::AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy, +AllocationInst::AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy, const std::string &Name, Instruction *InsertBefore) : UnaryInstruction(PointerType::get(Ty), iTy, getAISize(ArraySize), @@ -439,7 +439,7 @@ AllocationInst::AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy, assert(Ty != Type::VoidTy && "Cannot allocate void!"); } -AllocationInst::AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy, +AllocationInst::AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy, const std::string &Name, BasicBlock *InsertAtEnd) : UnaryInstruction(PointerType::get(Ty), iTy, getAISize(ArraySize), @@ -492,7 +492,7 @@ FreeInst::FreeInst(Value *Ptr, BasicBlock *InsertAtEnd) //===----------------------------------------------------------------------===// void LoadInst::AssertOK() { - assert(isa<PointerType>(getOperand(0)->getType()) && + assert(isa<PointerType>(getOperand(0)->getType()) && "Ptr must have pointer type."); } @@ -556,7 +556,7 @@ StoreInst::StoreInst(Value *val, Value *addr, BasicBlock *InsertAtEnd) AssertOK(); } -StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile, +StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile, Instruction *InsertBefore) : Instruction(Type::VoidTy, Store, Ops, 2, "", InsertBefore) { Ops[0].init(val, this); @@ -565,7 +565,7 @@ StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile, AssertOK(); } -StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile, +StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile, BasicBlock *InsertAtEnd) : Instruction(Type::VoidTy, Store, Ops, 2, "", InsertAtEnd) { Ops[0].init(val, this); @@ -642,10 +642,10 @@ GetElementPtrInst::~GetElementPtrInst() { // getIndexedType - Returns the type of the element that would be loaded with // a load instruction with the specified parameters. // -// A null type is returned if the indices are invalid for the specified +// A null type is returned if the indices are invalid for the specified // pointer type. // -const Type* GetElementPtrInst::getIndexedType(const Type *Ptr, +const Type* GetElementPtrInst::getIndexedType(const Type *Ptr, const std::vector<Value*> &Idx, bool AllowCompositeLeaf) { if (!isa<PointerType>(Ptr)) return 0; // Type isn't a pointer type! @@ -657,7 +657,7 @@ const Type* GetElementPtrInst::getIndexedType(const Type *Ptr, return cast<PointerType>(Ptr)->getElementType(); else return 0; - + unsigned CurIdx = 0; while (const CompositeType *CT = dyn_cast<CompositeType>(Ptr)) { if (Idx.size() == CurIdx) { @@ -682,7 +682,7 @@ const Type* GetElementPtrInst::getIndexedType(const Type *Ptr, return CurIdx == Idx.size() ? Ptr : 0; } -const Type* GetElementPtrInst::getIndexedType(const Type *Ptr, +const Type* GetElementPtrInst::getIndexedType(const Type *Ptr, Value *Idx0, Value *Idx1, bool AllowCompositeLeaf) { const PointerType *PTy = dyn_cast<PointerType>(Ptr); @@ -716,9 +716,9 @@ void BinaryOperator::init(BinaryOps iType) case Rem: assert(getType() == LHS->getType() && "Arithmetic operation should return same type as operands!"); - assert((getType()->isInteger() || - getType()->isFloatingPoint() || - isa<PackedType>(getType()) ) && + assert((getType()->isInteger() || + getType()->isFloatingPoint() || + isa<PackedType>(getType()) ) && "Tried to create an arithmetic operation on a non-arithmetic type!"); break; case And: case Or: @@ -870,7 +870,7 @@ bool BinaryOperator::swapOperands() { // SetCondInst Class //===----------------------------------------------------------------------===// -SetCondInst::SetCondInst(BinaryOps Opcode, Value *S1, Value *S2, +SetCondInst::SetCondInst(BinaryOps Opcode, Value *S1, Value *S2, const std::string &Name, Instruction *InsertBefore) : BinaryOperator(Opcode, S1, S2, Type::BoolTy, Name, InsertBefore) { @@ -878,7 +878,7 @@ SetCondInst::SetCondInst(BinaryOps Opcode, Value *S1, Value *S2, assert(getInverseCondition(Opcode)); } -SetCondInst::SetCondInst(BinaryOps Opcode, Value *S1, Value *S2, +SetCondInst::SetCondInst(BinaryOps Opcode, Value *S1, Value *S2, const std::string &Name, BasicBlock *InsertAtEnd) : BinaryOperator(Opcode, S1, S2, Type::BoolTy, Name, InsertAtEnd) { @@ -931,7 +931,7 @@ void SwitchInst::init(Value *Value, BasicBlock *Default, unsigned NumCases) { OperandList[1].init(Default, this); } -SwitchInst::SwitchInst(const SwitchInst &SI) +SwitchInst::SwitchInst(const SwitchInst &SI) : TerminatorInst(Instruction::Switch, new Use[SI.getNumOperands()], SI.getNumOperands()) { Use *OL = OperandList, *InOL = SI.OperandList; diff --git a/lib/VMCore/LeakDetector.cpp b/lib/VMCore/LeakDetector.cpp index c8e7f4c..7cf8e0d 100644 --- a/lib/VMCore/LeakDetector.cpp +++ b/lib/VMCore/LeakDetector.cpp @@ -1,10 +1,10 @@ //===-- LeakDetector.cpp - Implement LeakDetector interface ---------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements the LeakDetector class. diff --git a/lib/VMCore/Mangler.cpp b/lib/VMCore/Mangler.cpp index 14830cb..0847604 100644 --- a/lib/VMCore/Mangler.cpp +++ b/lib/VMCore/Mangler.cpp @@ -1,10 +1,10 @@ //===-- Mangler.cpp - Self-contained c/asm llvm name mangler --------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // Unified name mangler for CWriter and assembly backends. @@ -27,10 +27,10 @@ static std::string MangleLetter(unsigned char C) { /// makeNameProper - We don't want identifier names non-C-identifier characters /// in them, so mangle them as appropriate. -/// +/// std::string Mangler::makeNameProper(const std::string &X) { std::string Result; - + // Mangle the first letter specially, don't allow numbers... if ((X[0] < 'a' || X[0] > 'z') && (X[0] < 'A' || X[0] > 'Z') && X[0] != '_') Result += MangleLetter(X[0]); @@ -85,7 +85,7 @@ std::string Mangler::getValueName(const Value *V) { } else { name = "ltmp_" + utostr(Count++) + "_" + utostr(getTypeID(V->getType())); } - + Memo[V] = name; return name; } diff --git a/lib/VMCore/Module.cpp b/lib/VMCore/Module.cpp index f9b8ca1..a554d8e 100644 --- a/lib/VMCore/Module.cpp +++ b/lib/VMCore/Module.cpp @@ -1,10 +1,10 @@ //===-- Module.cpp - Implement the Module class ---------------------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements the Module class for the VMCore library. @@ -174,7 +174,7 @@ Function *Module::getMainFunction() { if (Function *F = getFunction("main", FunctionType::get(Type::IntTy, Params, false))) return F; - + // void main(int argc, char **argv)... if (Function *F = getFunction("main", FunctionType::get(Type::VoidTy, Params, false))) @@ -212,7 +212,7 @@ Function *Module::getNamedFunction(const std::string &Name) { /// have the top-level PointerType, which represents the address of the /// global. /// -GlobalVariable *Module::getGlobalVariable(const std::string &Name, +GlobalVariable *Module::getGlobalVariable(const std::string &Name, const Type *Ty) { if (Value *V = getSymbolTable().lookup(PointerType::get(Ty), Name)) { GlobalVariable *Result = cast<GlobalVariable>(V); @@ -237,7 +237,7 @@ bool Module::addTypeName(const std::string &Name, const Type *Ty) { SymbolTable &ST = getSymbolTable(); if (ST.lookupType(Name)) return true; // Already in symtab... - + // Not in symbol table? Set the name with the Symtab as an argument so the // type knows what to update... ST.insert(Name, Ty); diff --git a/lib/VMCore/ModuleProvider.cpp b/lib/VMCore/ModuleProvider.cpp index 2b06c11..c9e4d87 100644 --- a/lib/VMCore/ModuleProvider.cpp +++ b/lib/VMCore/ModuleProvider.cpp @@ -1,10 +1,10 @@ //===-- ModuleProvider.cpp - Base implementation for module providers -----===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // Minimal implementation of the abstract interface for providing a module. diff --git a/lib/VMCore/Pass.cpp b/lib/VMCore/Pass.cpp index acde824..4ed7847 100644 --- a/lib/VMCore/Pass.cpp +++ b/lib/VMCore/Pass.cpp @@ -1,10 +1,10 @@ //===- Pass.cpp - LLVM Pass Infrastructure Implementation -----------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements the LLVM Pass infrastructure. It is primarily @@ -90,12 +90,12 @@ bool PassManager::run(Module &M) { return PM->runOnModule(M); } // is a simple Pimpl class that wraps the PassManagerT template. It // is like PassManager, but only deals in FunctionPasses. // -FunctionPassManager::FunctionPassManager(ModuleProvider *P) : +FunctionPassManager::FunctionPassManager(ModuleProvider *P) : PM(new PassManagerT<Function>()), MP(P) {} FunctionPassManager::~FunctionPassManager() { delete PM; } void FunctionPassManager::add(FunctionPass *P) { PM->add(P); } void FunctionPassManager::add(ImmutablePass *IP) { PM->add(IP); } -bool FunctionPassManager::run(Function &F) { +bool FunctionPassManager::run(Function &F) { try { MP->materializeFunction(&F); } catch (std::string& errstr) { @@ -149,7 +149,7 @@ void PMDebug::PrintArgumentInformation(const Pass *P) { void PMDebug::PrintPassInformation(unsigned Depth, const char *Action, Pass *P, Module *M) { if (PassDebugging >= Executions) { - std::cerr << (void*)P << std::string(Depth*2+1, ' ') << Action << " '" + std::cerr << (void*)P << std::string(Depth*2+1, ' ') << Action << " '" << P->getPassName(); if (M) std::cerr << "' on Module '" << M->getModuleIdentifier() << "'\n"; std::cerr << "'...\n"; @@ -159,7 +159,7 @@ void PMDebug::PrintPassInformation(unsigned Depth, const char *Action, void PMDebug::PrintPassInformation(unsigned Depth, const char *Action, Pass *P, Function *F) { if (PassDebugging >= Executions) { - std::cerr << (void*)P << std::string(Depth*2+1, ' ') << Action << " '" + std::cerr << (void*)P << std::string(Depth*2+1, ' ') << Action << " '" << P->getPassName(); if (F) std::cerr << "' on Function '" << F->getName(); std::cerr << "'...\n"; @@ -169,7 +169,7 @@ void PMDebug::PrintPassInformation(unsigned Depth, const char *Action, void PMDebug::PrintPassInformation(unsigned Depth, const char *Action, Pass *P, BasicBlock *BB) { if (PassDebugging >= Executions) { - std::cerr << (void*)P << std::string(Depth*2+1, ' ') << Action << " '" + std::cerr << (void*)P << std::string(Depth*2+1, ' ') << Action << " '" << P->getPassName(); if (BB) std::cerr << "' on BasicBlock '" << BB->getName(); std::cerr << "'...\n"; @@ -244,11 +244,11 @@ void ImmutablePass::addToPassManager(PassManagerT<Module> *PM, // bool FunctionPass::runOnModule(Module &M) { bool Changed = doInitialization(M); - + for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) if (!I->isExternal()) // Passes are not run on external functions! Changed |= runOnFunction(*I); - + return Changed | doFinalization(M); } @@ -441,7 +441,7 @@ RegisterAGBase::~RegisterAGBase() { if (AGI.DefaultImpl == ImplementationInfo) AGI.DefaultImpl = 0; - + AGI.Implementations.erase(ImplementationInfo); // Last member of this analysis group? Unregister PassInfo, delete map entry diff --git a/lib/VMCore/PassManagerT.h b/lib/VMCore/PassManagerT.h index 8b3425a..b679f6f 100644 --- a/lib/VMCore/PassManagerT.h +++ b/lib/VMCore/PassManagerT.h @@ -1,10 +1,10 @@ //===- PassManagerT.h - Container for Passes --------------------*- C++ -*-===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file defines the PassManagerT class. This class is used to hold, @@ -131,7 +131,7 @@ template<class UnitType> class PassManagerTraits; // Do not define. //===----------------------------------------------------------------------===// // PassManagerT - Container object for passes. The PassManagerT destructor -// deletes all passes contained inside of the PassManagerT, so you shouldn't +// deletes all passes contained inside of the PassManagerT, so you shouldn't // delete passes manually, and all passes should be dynamically allocated. // template<typename UnitType> @@ -147,7 +147,7 @@ class PassManagerT : public PassManagerTraits<UnitType>,public AnalysisResolver{ friend SubPassClass; #else friend class PassManagerTraits<UnitType>::PassClass; - friend class PassManagerTraits<UnitType>::SubPassClass; + friend class PassManagerTraits<UnitType>::SubPassClass; #endif friend class PassManagerTraits<UnitType>; friend class ImmutablePass; @@ -219,7 +219,7 @@ public: // Run all of the passes for (unsigned i = 0, e = Passes.size(); i < e; ++i) { PassClass *P = Passes[i]; - + PMDebug::PrintPassInformation(getDepth(), "Executing Pass", P, M); // Get information about what analyses the pass uses... @@ -236,7 +236,7 @@ public: P->AnalysisImpls.clear(); P->AnalysisImpls.reserve(AnUsage.getRequiredSet().size()); for (std::vector<const PassInfo *>::const_iterator - I = AnUsage.getRequiredSet().begin(), + I = AnUsage.getRequiredSet().begin(), E = AnUsage.getRequiredSet().end(); I != E; ++I) { Pass *Impl = getAnalysisOrNullUp(*I); if (Impl == 0) { @@ -353,7 +353,7 @@ public: const PassInfo *IPID = ImmutablePasses[i]->getPassInfo(); if (IPID == ID) return ImmutablePasses[i]; - + // This pass is the current implementation of all of the interfaces it // implements as well. // @@ -420,14 +420,14 @@ public: if (Parent) { Parent->markPassUsed(P, this); } else { - assert(getAnalysisOrNullUp(P) && + assert(getAnalysisOrNullUp(P) && dynamic_cast<ImmutablePass*>(getAnalysisOrNullUp(P)) && "Pass available but not found! " "Perhaps this is a module pass requiring a function pass?"); } } } - + // Return the number of parent PassManagers that exist virtual unsigned getDepth() const { if (Parent == 0) return 0; @@ -514,8 +514,8 @@ private: //const std::vector<AnalysisID> &ProvidedSet = AnUsage.getProvidedSet(); if (Batcher /*&& ProvidedSet.empty()*/) closeBatcher(); // This pass cannot be batched! - - // Set the Resolver instance variable in the Pass so that it knows where to + + // Set the Resolver instance variable in the Pass so that it knows where to // find this object... // setAnalysisResolver(P, this); @@ -559,7 +559,7 @@ private: // For now assume that our results are never used... LastUseOf[P] = P; } - + // For FunctionPass subclasses, we must be sure to batch the FunctionPass's // together in a BatcherClass object so that all of the analyses are run // together a function at a time. @@ -588,7 +588,7 @@ public: return; } - // Set the Resolver instance variable in the Pass so that it knows where to + // Set the Resolver instance variable in the Pass so that it knows where to // find this object... // setAnalysisResolver(IP, this); @@ -601,7 +601,7 @@ public: // IP->AnalysisImpls.clear(); IP->AnalysisImpls.reserve(AU.getRequiredSet().size()); - for (std::vector<const PassInfo *>::const_iterator + for (std::vector<const PassInfo *>::const_iterator I = AU.getRequiredSet().begin(), E = AU.getRequiredSet().end(); I != E; ++I) { Pass *Impl = getAnalysisOrNullUp(*I); @@ -616,7 +616,7 @@ public: } IP->AnalysisImpls.push_back(std::make_pair(*I, Impl)); } - + // Initialize the immutable pass... IP->initializePass(); } @@ -642,7 +642,7 @@ public: typedef PassManagerT<Module> SubPassClass; // BatcherClass - The type to use for collation of subtypes... This class is - // never instantiated for the PassManager<BasicBlock>, but it must be an + // never instantiated for the PassManager<BasicBlock>, but it must be an // instance of PassClass to typecheck. // typedef PassClass BatcherClass; diff --git a/lib/VMCore/SymbolTable.cpp b/lib/VMCore/SymbolTable.cpp index 0881c41..3290fbd 100644 --- a/lib/VMCore/SymbolTable.cpp +++ b/lib/VMCore/SymbolTable.cpp @@ -1,11 +1,11 @@ //===-- SymbolTable.cpp - Implement the SymbolTable class -----------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and revised by Reid -// Spencer. It is distributed under the University of Illinois Open Source +// Spencer. It is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements the SymbolTable class for the VMCore library. @@ -31,7 +31,7 @@ SymbolTable::~SymbolTable() { cast<DerivedType>(TI->second)->removeAbstractTypeUser(this); } - // TODO: FIXME: BIG ONE: This doesn't unreference abstract types for the + // TODO: FIXME: BIG ONE: This doesn't unreference abstract types for the // planes that could still have entries! #ifndef NDEBUG // Only do this in -g mode... @@ -45,7 +45,7 @@ SymbolTable::~SymbolTable() { LeftoverValues = false; } } - + assert(LeftoverValues && "Values remain in symbol table!"); #endif } @@ -194,7 +194,7 @@ void SymbolTable::insertEntry(const std::string &Name, const Type *VTy, #if DEBUG_SYMBOL_TABLE dump(); - std::cerr << " Inserting definition: " << Name << ": " + std::cerr << " Inserting definition: " << Name << ": " << VTy->getDescription() << "\n"; #endif @@ -243,7 +243,7 @@ void SymbolTable::insert(const std::string& Name, const Type* T) { #if DEBUG_SYMBOL_TABLE dump(); - std::cerr << " Inserting type: " << UniqueName << ": " + std::cerr << " Inserting type: " << UniqueName << ": " << T->getDescription() << "\n"; #endif @@ -282,7 +282,7 @@ bool SymbolTable::strip() { remove(TI++); RemovedSymbol = true; } - + return RemovedSymbol; } @@ -299,7 +299,7 @@ void SymbolTable::refineAbstractType(const DerivedType *OldType, plane_iterator NewTypeIt = pmap.find(NewType); if (NewTypeIt == pmap.end()) { // If no plane exists, add one NewTypeIt = pmap.insert(make_pair(NewType, ValueMap())).first; - + if (NewType->isAbstract()) { cast<DerivedType>(NewType)->addAbstractTypeUser(this); #if DEBUG_ABSTYPE @@ -338,7 +338,7 @@ void SymbolTable::refineAbstractType(const DerivedType *OldType, // Ok we have two external global values. Make all uses of the new // one use the old one... NewGV->uncheckedReplaceAllUsesWith(ExistGV); - + // Update NewGV's name, we're about the remove it from the symbol // table. NewGV->Name = ""; @@ -387,7 +387,7 @@ void SymbolTable::refineAbstractType(const DerivedType *OldType, std::cerr << "Removing type " << OldType->getDescription() << "\n"; #endif OldType->removeAbstractTypeUser(this); - + I->second = (Type*)NewType; // TODO FIXME when types aren't const if (NewType->isAbstract()) { #if DEBUG_ABSTYPE diff --git a/lib/VMCore/SymbolTableListTraitsImpl.h b/lib/VMCore/SymbolTableListTraitsImpl.h index 22d2e1d..6d70401 100644 --- a/lib/VMCore/SymbolTableListTraitsImpl.h +++ b/lib/VMCore/SymbolTableListTraitsImpl.h @@ -1,10 +1,10 @@ //===-- llvm/SymbolTableListTraitsImpl.h - Implementation ------*- C++ -*--===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements the stickier parts of the SymbolTableListTraits class, diff --git a/lib/VMCore/Type.cpp b/lib/VMCore/Type.cpp index 2bcda46..3e5757b 100644 --- a/lib/VMCore/Type.cpp +++ b/lib/VMCore/Type.cpp @@ -1,10 +1,10 @@ //===-- Type.cpp - Implement the Type class -------------------------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements the Type class for the VMCore library. @@ -103,13 +103,13 @@ const Type *Type::getUnsignedVersion() const { switch (getTypeID()) { default: assert(isInteger()&&"Type::getUnsignedVersion is only valid for integers!"); - case Type::UByteTyID: + case Type::UByteTyID: case Type::SByteTyID: return Type::UByteTy; - case Type::UShortTyID: + case Type::UShortTyID: case Type::ShortTyID: return Type::UShortTy; - case Type::UIntTyID: + case Type::UIntTyID: case Type::IntTyID: return Type::UIntTy; - case Type::ULongTyID: + case Type::ULongTyID: case Type::LongTyID: return Type::ULongTy; } } @@ -120,13 +120,13 @@ const Type *Type::getSignedVersion() const { switch (getTypeID()) { default: assert(isInteger() && "Type::getSignedVersion is only valid for integers!"); - case Type::UByteTyID: + case Type::UByteTyID: case Type::SByteTyID: return Type::SByteTy; - case Type::UShortTyID: + case Type::UShortTyID: case Type::ShortTyID: return Type::ShortTy; - case Type::UIntTyID: + case Type::UIntTyID: case Type::IntTyID: return Type::IntTy; - case Type::ULongTyID: + case Type::ULongTyID: case Type::LongTyID: return Type::LongTy; } } @@ -167,7 +167,7 @@ bool Type::isSizedDerivedType() const { /// algorithm for when a type is being forwarded to another type. const Type *Type::getForwardedTypeInternal() const { assert(ForwardType && "This type is not being forwarded to another type!"); - + // Check to see if the forwarded type has been forwarded on. If so, collapse // the forwarding links. const Type *RealForwardedType = ForwardType->getForwardedType(); @@ -181,7 +181,7 @@ const Type *Type::getForwardedTypeInternal() const { // Now drop the old reference. This could cause ForwardType to get deleted. cast<DerivedType>(ForwardType)->dropRef(); - + // Return the updated type. ForwardType = RealForwardedType; return ForwardType; @@ -201,28 +201,28 @@ static std::string getTypeDescription(const Type *Ty, AbstractTypeDescriptions.insert(std::make_pair(Ty, Desc)); return Desc; } - + if (!Ty->isAbstract()) { // Base case for the recursion std::map<const Type*, std::string>::iterator I = ConcreteTypeDescriptions.find(Ty); if (I != ConcreteTypeDescriptions.end()) return I->second; } - + // Check to see if the Type is already on the stack... unsigned Slot = 0, CurSize = TypeStack.size(); while (Slot < CurSize && TypeStack[Slot] != Ty) ++Slot; // Scan for type - - // This is another base case for the recursion. In this case, we know + + // This is another base case for the recursion. In this case, we know // that we have looped back to a type that we have previously visited. // Generate the appropriate upreference to handle this. - // + // if (Slot < CurSize) return "\\" + utostr(CurSize-Slot); // Here's the upreference // Recursive case: derived types... std::string Result; TypeStack.push_back(Ty); // Add us to the stack.. - + switch (Ty->getTypeID()) { case Type::FunctionTyID: { const FunctionType *FTy = cast<FunctionType>(Ty); @@ -289,7 +289,7 @@ static const std::string &getOrCreateDesc(std::map<const Type*,std::string>&Map, const Type *Ty) { std::map<const Type*, std::string>::iterator I = Map.find(Ty); if (I != Map.end()) return I->second; - + std::vector<const Type *> TypeStack; std::string Result = getTypeDescription(Ty, TypeStack); return Map[Ty] = Result; @@ -366,11 +366,11 @@ Type *Type::LabelTy = &TheLabelTy; //===----------------------------------------------------------------------===// FunctionType::FunctionType(const Type *Result, - const std::vector<const Type*> &Params, - bool IsVarArgs) : DerivedType(FunctionTyID), + const std::vector<const Type*> &Params, + bool IsVarArgs) : DerivedType(FunctionTyID), isVarArgs(IsVarArgs) { assert((Result->isFirstClassType() || Result == Type::VoidTy || - isa<OpaqueType>(Result)) && + isa<OpaqueType>(Result)) && "LLVM functions cannot return aggregates"); bool isAbstract = Result->isAbstract(); ContainedTys.reserve(Params.size()+1); @@ -415,7 +415,7 @@ PackedType::PackedType(const Type *ElType, unsigned NumEl) NumElements = NumEl; assert(NumEl > 0 && "NumEl of a PackedType must be greater than 0"); - assert((ElType->isIntegral() || ElType->isFloatingPoint()) && + assert((ElType->isIntegral() || ElType->isFloatingPoint()) && "Elements of a PackedType must be a primitive type"); } @@ -439,7 +439,7 @@ void DerivedType::dropAllTypeUses() { if (!ContainedTys.empty()) { while (ContainedTys.size() > 1) ContainedTys.pop_back(); - + // The type must stay abstract. To do this, we insert a pointer to a type // that will never get resolved, thus will always be abstract. static Type *AlwaysOpaqueTy = OpaqueType::get(); @@ -463,15 +463,15 @@ namespace llvm { template <> struct GraphTraits<TypePromotionGraph> { typedef Type NodeType; typedef Type::subtype_iterator ChildIteratorType; - + static inline NodeType *getEntryNode(TypePromotionGraph G) { return G.Ty; } - static inline ChildIteratorType child_begin(NodeType *N) { + static inline ChildIteratorType child_begin(NodeType *N) { if (N->isAbstract()) - return N->subtype_begin(); + return N->subtype_begin(); else // No need to process children of concrete types. - return N->subtype_end(); + return N->subtype_end(); } - static inline ChildIteratorType child_end(NodeType *N) { + static inline ChildIteratorType child_end(NodeType *N) { return N->subtype_end(); } }; @@ -507,12 +507,12 @@ void Type::PromoteAbstractToConcrete() { // abstract unless there is a non-SCC abstract type. if (std::find(SCC.begin(), SCC.end(), *CI) == SCC.end()) return; // Not going to be concrete, sorry. - + // Okay, we just discovered this whole SCC is now concrete, mark it as // such! for (unsigned i = 0, e = SCC.size(); i != e; ++i) { assert(SCC[i]->isAbstract() && "Why are we processing concrete types?"); - + SCC[i]->setAbstract(false); } @@ -606,7 +606,7 @@ static bool AbstractTypeHasCycleThrough(const Type *TargetTy, const Type *CurTy, if (!VisitedTypes.insert(CurTy).second) return false; // Already been here. - for (Type::subtype_iterator I = CurTy->subtype_begin(), + for (Type::subtype_iterator I = CurTy->subtype_begin(), E = CurTy->subtype_end(); I != E; ++I) if (AbstractTypeHasCycleThrough(TargetTy, *I, VisitedTypes)) return true; @@ -620,7 +620,7 @@ static bool ConcreteTypeHasCycleThrough(const Type *TargetTy, const Type *CurTy, if (!VisitedTypes.insert(CurTy).second) return false; // Already been here. - for (Type::subtype_iterator I = CurTy->subtype_begin(), + for (Type::subtype_iterator I = CurTy->subtype_begin(), E = CurTy->subtype_end(); I != E; ++I) if (ConcreteTypeHasCycleThrough(TargetTy, *I, VisitedTypes)) return true; @@ -633,7 +633,7 @@ static bool TypeHasCycleThroughItself(const Type *Ty) { std::set<const Type*> VisitedTypes; if (Ty->isAbstract()) { // Optimized case for abstract types. - for (Type::subtype_iterator I = Ty->subtype_begin(), E = Ty->subtype_end(); + for (Type::subtype_iterator I = Ty->subtype_begin(), E = Ty->subtype_end(); I != E; ++I) if (AbstractTypeHasCycleThrough(Ty, *I, VisitedTypes)) return true; @@ -670,7 +670,7 @@ class TypeMap { private: void clear(std::vector<Type *> &DerivedTypes) { - for (typename std::map<ValType, PATypeHolder>::iterator I = Map.begin(), + for (typename std::map<ValType, PATypeHolder>::iterator I = Map.begin(), E = Map.end(); I != E; ++I) DerivedTypes.push_back(I->second.get()); TypesByHash.clear(); @@ -694,7 +694,7 @@ public: } void RemoveFromTypesByHash(unsigned Hash, const Type *Ty) { - std::multimap<unsigned, PATypeHolder>::iterator I = + std::multimap<unsigned, PATypeHolder>::iterator I = TypesByHash.lower_bound(Hash); while (I->second != Ty) { ++I; @@ -736,7 +736,7 @@ public: } unsigned TypeHash = ValType::hashTypeStructure(Ty); - + // If there are no cycles going through this node, we can do a simple, // efficient lookup in the map, instead of an inefficient nasty linear // lookup. @@ -756,7 +756,7 @@ public: Ty->refineAbstractTypeTo(NewTy); return; } - + } else { // Now we check to see if there is an existing entry in the table which is // structurally identical to the newly refined type. If so, this type @@ -770,7 +770,7 @@ public: if (TypesEqual(Ty, I->second)) { assert(Ty->isAbstract() && "Replacing a non-abstract type?"); TypeClass *NewTy = cast<TypeClass>((Type*)I->second.get()); - + if (Entry == E) { // Find the location of Ty in the TypesByHash structure. while (I->second != Ty) { @@ -785,7 +785,7 @@ public: return; } } else { - // Remember the position of + // Remember the position of Entry = I; } } @@ -807,14 +807,14 @@ public: if (Ty->isAbstract()) Ty->PromoteAbstractToConcrete(); } - + void print(const char *Arg) const { #ifdef DEBUG_MERGE_TYPES std::cerr << "TypeMap<>::" << Arg << " table contents:\n"; unsigned i = 0; for (typename std::map<ValType, PATypeHolder>::const_iterator I = Map.begin(), E = Map.end(); I != E; ++I) - std::cerr << " " << (++i) << ". " << (void*)I->second.get() << " " + std::cerr << " " << (++i) << ". " << (void*)I->second.get() << " " << *I->second.get() << "\n"; #endif } @@ -879,7 +879,7 @@ FunctionValType FunctionValType::get(const FunctionType *FT) { // FunctionType::get - The factory function for the FunctionType class... -FunctionType *FunctionType::get(const Type *ReturnType, +FunctionType *FunctionType::get(const Type *ReturnType, const std::vector<const Type*> &Params, bool isVarArg) { FunctionValType VT(ReturnType, Params, isVarArg); @@ -1010,7 +1010,7 @@ public: ElTypes.reserve(ST->getNumElements()); for (unsigned i = 0, e = ST->getNumElements(); i != e; ++i) ElTypes.push_back(ST->getElementType(i)); - + return StructValType(ElTypes); } @@ -1121,12 +1121,12 @@ void DerivedType::removeAbstractTypeUser(AbstractTypeUser *U) const { assert(i < AbstractTypeUsers.size() && "Index out of range!"); // Wraparound? AbstractTypeUsers.erase(AbstractTypeUsers.begin()+i); - + #ifdef DEBUG_MERGE_TYPES std::cerr << " remAbstractTypeUser[" << (void*)this << ", " << *this << "][" << i << "] User = " << U << "\n"; #endif - + if (AbstractTypeUsers.empty() && getRefCount() == 0 && isAbstract()) { #ifdef DEBUG_MERGE_TYPES std::cerr << "DELETEing unused abstract type: <" << *this @@ -1223,7 +1223,7 @@ void DerivedType::notifyUsesThatTypeBecameConcrete() { "AbstractTypeUser did not remove itself from the use list!"); } } - + @@ -1333,7 +1333,7 @@ void Type::clearAllTypeMaps() { ArrayTypes.clear(DerivedTypes); PackedTypes.clear(DerivedTypes); - for(std::vector<Type *>::iterator I = DerivedTypes.begin(), + for(std::vector<Type *>::iterator I = DerivedTypes.begin(), E = DerivedTypes.end(); I != E; ++I) (*I)->ContainedTys.clear(); for(std::vector<Type *>::iterator I = DerivedTypes.begin(), diff --git a/lib/VMCore/Value.cpp b/lib/VMCore/Value.cpp index dd06441..f59e8ef 100644 --- a/lib/VMCore/Value.cpp +++ b/lib/VMCore/Value.cpp @@ -1,13 +1,13 @@ //===-- Value.cpp - Implement the Value class -----------------------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // -// This file implements the Value and User classes. +// This file implements the Value and User classes. // //===----------------------------------------------------------------------===// @@ -34,7 +34,7 @@ Value::Value(const Type *ty, unsigned scid, const std::string &name) : SubclassID(scid), SubclassData(0), Ty(checkType(ty)), UseList(0), Name(name) { if (!isa<Constant>(this) && !isa<BasicBlock>(this)) - assert((Ty->isFirstClassType() || Ty == Type::VoidTy || + assert((Ty->isFirstClassType() || Ty == Type::VoidTy || isa<OpaqueType>(ty)) && "Cannot create non-first-class values except for constants!"); if (ty == Type::VoidTy) @@ -46,7 +46,7 @@ Value::~Value() { // Check to make sure that there are no uses of this value that are still // around when the value is destroyed. If there are, then we have a dangling // reference and something is wrong. This code is here to print out what is - // still being referenced. The value in question should be printed as + // still being referenced. The value in question should be printed as // a <badref> // if (use_begin() != use_end()) { @@ -142,7 +142,7 @@ void Value::uncheckedReplaceAllUsesWith(Value *New) { if (Constant *C = dyn_cast<Constant>(U.getUser())) { if (!isa<GlobalValue>(C)) C->replaceUsesOfWithOnConstant(this, New, true); - else + else U.set(New); } else { U.set(New); diff --git a/lib/VMCore/Verifier.cpp b/lib/VMCore/Verifier.cpp index 3964817..da14c00 100644 --- a/lib/VMCore/Verifier.cpp +++ b/lib/VMCore/Verifier.cpp @@ -1,10 +1,10 @@ //===-- Verifier.cpp - Implement the Module Verifier -------------*- C++ -*-==// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file defines the function verifier interface, that can be used for some @@ -76,17 +76,17 @@ namespace { // Anonymous namespace for class /// an instruction in the same block. std::set<Instruction*> InstsInThisBlock; - Verifier() + Verifier() : Broken(false), RealPass(true), action(AbortProcessAction), DS(0), msgs( std::ios::app | std::ios::out ) {} Verifier( VerifierFailureAction ctn ) - : Broken(false), RealPass(true), action(ctn), DS(0), + : Broken(false), RealPass(true), action(ctn), DS(0), msgs( std::ios::app | std::ios::out ) {} - Verifier(bool AB ) - : Broken(false), RealPass(true), - action( AB ? AbortProcessAction : PrintMessageAction), DS(0), + Verifier(bool AB ) + : Broken(false), RealPass(true), + action( AB ? AbortProcessAction : PrintMessageAction), DS(0), msgs( std::ios::app | std::ios::out ) {} - Verifier(DominatorSet &ds) + Verifier(DominatorSet &ds) : Broken(false), RealPass(false), action(PrintMessageAction), DS(&ds), msgs( std::ios::app | std::ios::out ) {} @@ -223,7 +223,7 @@ namespace { // Anonymous namespace for class Broken = true; } - void CheckFailed( const std::string& Message, const Value* V1, + void CheckFailed( const std::string& Message, const Value* V1, const Type* T2, const Value* V3 = 0 ) { msgs << Message << "\n"; WriteValue(V1); @@ -264,11 +264,11 @@ void Verifier::visitGlobalValue(GlobalValue &GV) { } void Verifier::visitGlobalVariable(GlobalVariable &GV) { - if (GV.hasInitializer()) + if (GV.hasInitializer()) Assert1(GV.getInitializer()->getType() == GV.getType()->getElementType(), "Global variable initializer type does not match global " "variable type!", &GV); - + visitGlobalValue(GV); } @@ -278,7 +278,7 @@ void Verifier::visitGlobalVariable(GlobalVariable &GV) { void Verifier::verifySymbolTable(SymbolTable &ST) { // Loop over all of the values in all type planes in the symbol table. - for (SymbolTable::plane_const_iterator PI = ST.plane_begin(), + for (SymbolTable::plane_const_iterator PI = ST.plane_begin(), PE = ST.plane_end(); PI != PE; ++PI) for (SymbolTable::value_const_iterator VI = PI->second.begin(), VE = PI->second.end(); VI != VE; ++VI) { @@ -312,7 +312,7 @@ void Verifier::visitFunction(Function &F) { "Argument value does not match function argument type!", I, FT->getParamType(i)); // Make sure no aggregates are passed by value. - Assert1(I->getType()->isFirstClassType(), + Assert1(I->getType()->isFirstClassType(), "Functions cannot take aggregates as arguments by value!", I); } @@ -340,7 +340,7 @@ void Verifier::visitBasicBlock(BasicBlock &BB) { if (isa<PHINode>(BB.front())) { std::vector<BasicBlock*> Preds(pred_begin(&BB), pred_end(&BB)); std::sort(Preds.begin(), Preds.end()); - PHINode *PN; + PHINode *PN; for (BasicBlock::iterator I = BB.begin(); (PN = dyn_cast<PHINode>(I));++I) { // Ensure that PHI nodes have at least one entry! @@ -350,7 +350,7 @@ void Verifier::visitBasicBlock(BasicBlock &BB) { Assert1(PN->getNumIncomingValues() == Preds.size(), "PHINode should have one entry for each predecessor of its " "parent basic block!", PN); - + // Get and sort all incoming values in the PHI node... std::vector<std::pair<BasicBlock*, Value*> > Values; Values.reserve(PN->getNumIncomingValues()); @@ -358,7 +358,7 @@ void Verifier::visitBasicBlock(BasicBlock &BB) { Values.push_back(std::make_pair(PN->getIncomingBlock(i), PN->getIncomingValue(i))); std::sort(Values.begin(), Values.end()); - + for (unsigned i = 0, e = Values.size(); i != e; ++i) { // Check to make sure that if there is more than one entry for a // particular basic block in this PHI node, that the incoming values are @@ -369,12 +369,12 @@ void Verifier::visitBasicBlock(BasicBlock &BB) { "PHI node has multiple entries for the same basic block with " "different incoming values!", PN, Values[i].first, Values[i].second, Values[i-1].second); - + // Check to make sure that the predecessors and PHI node entries are // matched up. Assert3(Values[i].first == Preds[i], "PHI node entries do not match predecessors!", PN, - Values[i].first, Preds[i]); + Values[i].first, Preds[i]); } } } @@ -509,11 +509,11 @@ void Verifier::visitBinaryOperator(BinaryOperator &B) { Assert1(B.getType() == B.getOperand(0)->getType(), "Arithmetic operators must have same type for operands and result!", &B); - Assert1(B.getType()->isInteger() || B.getType()->isFloatingPoint() || + Assert1(B.getType()->isInteger() || B.getType()->isFloatingPoint() || isa<PackedType>(B.getType()), "Arithmetic operators must have integer, fp, or packed type!", &B); } - + visitInstruction(B); } @@ -557,7 +557,7 @@ void Verifier::visitStoreInst(StoreInst &SI) { /// verifyInstruction - Verify that an instruction is well formed. /// void Verifier::visitInstruction(Instruction &I) { - BasicBlock *BB = I.getParent(); + BasicBlock *BB = I.getParent(); Assert1(BB, "Instruction not embedded in basic block!", &I); if (!isa<PHINode>(I)) { // Check that non-phi nodes are not self referential @@ -749,13 +749,13 @@ void Verifier::visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI) { case Intrinsic::memset: NumArgs = 4; break; case Intrinsic::prefetch: NumArgs = 3; break; - case Intrinsic::pcmarker: - NumArgs = 1; + case Intrinsic::pcmarker: + NumArgs = 1; Assert1(isa<Constant>(CI.getOperand(1)), "First argument to llvm.pcmarker must be a constant!", &CI); break; - - case Intrinsic::not_intrinsic: + + case Intrinsic::not_intrinsic: assert(0 && "Invalid intrinsic!"); NumArgs = 0; break; } @@ -774,11 +774,11 @@ FunctionPass *llvm::createVerifierPass(VerifierFailureAction action) { } -// verifyFunction - Create +// verifyFunction - Create bool llvm::verifyFunction(const Function &f, VerifierFailureAction action) { Function &F = const_cast<Function&>(f); assert(!F.isExternal() && "Cannot verify external functions"); - + FunctionPassManager FPM(new ExistingModuleProvider(F.getParent())); Verifier *V = new Verifier(action); FPM.add(V); diff --git a/projects/Stacker/lib/compiler/StackerCompiler.cpp b/projects/Stacker/lib/compiler/StackerCompiler.cpp index 57a35a6..7b1ebe0 100644 --- a/projects/Stacker/lib/compiler/StackerCompiler.cpp +++ b/projects/Stacker/lib/compiler/StackerCompiler.cpp @@ -1,11 +1,11 @@ //===-- StackerCompiler.cpp - Parser for llvm assembly files ----*- C++ -*-===// -// +// // The LLVM Compiler Infrastructure // -// This file was developed by Reid Spencer and donated to the LLVM research -// group and is distributed under the University of Illinois Open Source +// This file was developed by Reid Spencer and donated to the LLVM research +// group and is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements the compiler for the "Stacker" language. @@ -13,7 +13,7 @@ //===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===// -// Globasl - Global variables we use +// Globasl - Global variables we use //===----------------------------------------------------------------------===// #include "llvm/PassManager.h" @@ -72,9 +72,9 @@ StackerCompiler::StackerCompiler() StackerCompiler::~StackerCompiler() { - // delete TheModule; << don't do this! - // TheModule is passed to caller of the compile() method .. its their - // problem. Likewise for the other allocated objects (which become part + // delete TheModule; << don't do this! + // TheModule is passed to caller of the compile() method .. its their + // problem. Likewise for the other allocated objects (which become part // of TheModule. TheModule = 0; DefinitionType = 0; @@ -104,19 +104,19 @@ StackerCompiler::compile( FILE *F = stdin; /// - if (filename != "-") + if (filename != "-") { F = fopen(filename.c_str(), "r"); if (F == 0) { - throw ParseException(filename, + throw ParseException(filename, "Could not open file '" + filename + "'"); } } Module *Result; - try + try { // Create the module we'll return TheModule = new Module( CurFilename ); @@ -124,115 +124,115 @@ StackerCompiler::compile( // Tell the module about our runtime library TheModule->addLibrary("stkr_runtime"); - // Create a type to represent the stack. This is the same as the LLVM + // Create a type to represent the stack. This is the same as the LLVM // Assembly type [ 256 x long ] stack_type = ArrayType::get( Type::LongTy, stack_size ); - // Create a global variable for the stack. Note the use of appending - // linkage linkage so that multiple modules will make the stack larger. - // Also note that the last argument causes the global to be inserted + // Create a global variable for the stack. Note the use of appending + // linkage linkage so that multiple modules will make the stack larger. + // Also note that the last argument causes the global to be inserted // automatically into the module. - TheStack = new GlobalVariable( - /*type=*/ stack_type, - /*isConstant=*/ false, - /*Linkage=*/ GlobalValue::LinkOnceLinkage, + TheStack = new GlobalVariable( + /*type=*/ stack_type, + /*isConstant=*/ false, + /*Linkage=*/ GlobalValue::LinkOnceLinkage, /*initializer=*/ Constant::getNullValue(stack_type), /*name=*/ "_stack_", - /*parent=*/ TheModule + /*parent=*/ TheModule ); - // Create a global variable for indexing into the stack. Note the use - // of LinkOnce linkage. Only one copy of _index_ will be retained + // Create a global variable for indexing into the stack. Note the use + // of LinkOnce linkage. Only one copy of _index_ will be retained // after linking - TheIndex = new GlobalVariable( - /*type=*/Type::LongTy, + TheIndex = new GlobalVariable( + /*type=*/Type::LongTy, /*isConstant=*/false, - /*Linkage=*/GlobalValue::LinkOnceLinkage, + /*Linkage=*/GlobalValue::LinkOnceLinkage, /*initializer=*/ Constant::getNullValue(Type::LongTy), /*name=*/"_index_", /*parent=*/TheModule ); - // Create a function prototype for definitions. No parameters, no + // Create a function prototype for definitions. No parameters, no // result. This is used below any time a function is created. std::vector<const Type*> params; // No parameters DefinitionType = FunctionType::get( Type::VoidTy, params, false ); // Create a function for printf(3) params.push_back( PointerType::get( Type::SByteTy ) ); - FunctionType* printf_type = + FunctionType* printf_type = FunctionType::get( Type::IntTy, params, true ); - ThePrintf = new Function( + ThePrintf = new Function( printf_type, GlobalValue::ExternalLinkage, "printf", TheModule); // Create a function for scanf(3) - TheScanf = new Function( + TheScanf = new Function( printf_type, GlobalValue::ExternalLinkage, "scanf", TheModule); // Create a function for exit(3) params.clear(); params.push_back( Type::IntTy ); - FunctionType* exit_type = + FunctionType* exit_type = FunctionType::get( Type::VoidTy, params, false ); - TheExit = new Function( + TheExit = new Function( exit_type, GlobalValue::ExternalLinkage, "exit", TheModule); Constant* str_format = ConstantArray::get("%s"); - StrFormat = new GlobalVariable( + StrFormat = new GlobalVariable( /*type=*/ArrayType::get( Type::SByteTy, 3 ), /*isConstant=*/true, - /*Linkage=*/GlobalValue::LinkOnceLinkage, - /*initializer=*/str_format, + /*Linkage=*/GlobalValue::LinkOnceLinkage, + /*initializer=*/str_format, /*name=*/"_str_format_", /*parent=*/TheModule ); Constant* in_str_format = ConstantArray::get(" %as"); - InStrFormat = new GlobalVariable( + InStrFormat = new GlobalVariable( /*type=*/ArrayType::get( Type::SByteTy, 5 ), /*isConstant=*/true, - /*Linkage=*/GlobalValue::LinkOnceLinkage, - /*initializer=*/in_str_format, + /*Linkage=*/GlobalValue::LinkOnceLinkage, + /*initializer=*/in_str_format, /*name=*/"_in_str_format_", /*parent=*/TheModule ); Constant* num_format = ConstantArray::get("%d"); - NumFormat = new GlobalVariable( + NumFormat = new GlobalVariable( /*type=*/ArrayType::get( Type::SByteTy, 3 ), /*isConstant=*/true, - /*Linkage=*/GlobalValue::LinkOnceLinkage, - /*initializer=*/num_format, + /*Linkage=*/GlobalValue::LinkOnceLinkage, + /*initializer=*/num_format, /*name=*/"_num_format_", /*parent=*/TheModule ); Constant* in_num_format = ConstantArray::get(" %d"); - InNumFormat = new GlobalVariable( + InNumFormat = new GlobalVariable( /*type=*/ArrayType::get( Type::SByteTy, 4 ), /*isConstant=*/true, - /*Linkage=*/GlobalValue::LinkOnceLinkage, - /*initializer=*/in_num_format, + /*Linkage=*/GlobalValue::LinkOnceLinkage, + /*initializer=*/in_num_format, /*name=*/"_in_num_format_", /*parent=*/TheModule ); Constant* chr_format = ConstantArray::get("%c"); - ChrFormat = new GlobalVariable( + ChrFormat = new GlobalVariable( /*type=*/ArrayType::get( Type::SByteTy, 3 ), /*isConstant=*/true, - /*Linkage=*/GlobalValue::LinkOnceLinkage, - /*initializer=*/chr_format, + /*Linkage=*/GlobalValue::LinkOnceLinkage, + /*initializer=*/chr_format, /*name=*/"_chr_format_", /*parent=*/TheModule ); Constant* in_chr_format = ConstantArray::get(" %c"); - InChrFormat = new GlobalVariable( + InChrFormat = new GlobalVariable( /*type=*/ArrayType::get( Type::SByteTy, 4 ), /*isConstant=*/true, - /*Linkage=*/GlobalValue::LinkOnceLinkage, - /*initializer=*/in_chr_format, + /*Linkage=*/GlobalValue::LinkOnceLinkage, + /*initializer=*/in_chr_format, /*name=*/"_in_chr_format_", /*parent=*/TheModule ); @@ -246,7 +246,7 @@ StackerCompiler::compile( Five = ConstantInt::get( Type::LongTy, 5 ); // Reset the current line number - Stackerlineno = 1; + Stackerlineno = 1; // Reset the parser's input to F Stackerin = F; // Set the input file. @@ -254,9 +254,9 @@ StackerCompiler::compile( // Let the parse know about this instance TheInstance = this; - // Parse the file. The parser (see StackParser.y) will call back to - // the StackerCompiler via the "handle*" methods - Stackerparse(); + // Parse the file. The parser (see StackParser.y) will call back to + // the StackerCompiler via the "handle*" methods + Stackerparse(); // Avoid potential illegal use (TheInstance might be on the stack) TheInstance = 0; @@ -266,20 +266,20 @@ StackerCompiler::compile( // Add in the passes we want to execute Passes.add(new TargetData("stkrc",TheModule)); // Verify we start with valid - Passes.add(createVerifierPass()); + Passes.add(createVerifierPass()); if (optLevel > 0) { if (optLevel > 1) { // Clean up disgusting code - Passes.add(createCFGSimplificationPass()); + Passes.add(createCFGSimplificationPass()); // Remove unused globals - Passes.add(createGlobalDCEPass()); + Passes.add(createGlobalDCEPass()); // IP Constant Propagation Passes.add(createIPConstantPropagationPass()); - // Clean up after IPCP - Passes.add(createInstructionCombiningPass()); - // Clean up after IPCP - Passes.add(createCFGSimplificationPass()); + // Clean up after IPCP + Passes.add(createInstructionCombiningPass()); + // Clean up after IPCP + Passes.add(createCFGSimplificationPass()); // Inline small definitions (functions) Passes.add(createFunctionInliningPass()); // Simplify cfg by copying code @@ -292,25 +292,25 @@ StackerCompiler::compile( // Reassociate expressions Passes.add(createReassociatePass()); // Combine silly seq's - Passes.add(createInstructionCombiningPass()); + Passes.add(createInstructionCombiningPass()); // Eliminate tail calls - Passes.add(createTailCallEliminationPass()); + Passes.add(createTailCallEliminationPass()); // Merge & remove BBs - Passes.add(createCFGSimplificationPass()); + Passes.add(createCFGSimplificationPass()); // Hoist loop invariants - Passes.add(createLICMPass()); + Passes.add(createLICMPass()); // Clean up after the unroller - Passes.add(createInstructionCombiningPass()); + Passes.add(createInstructionCombiningPass()); // Canonicalize indvars - Passes.add(createIndVarSimplifyPass()); + Passes.add(createIndVarSimplifyPass()); // Unroll small loops - Passes.add(createLoopUnrollPass()); + Passes.add(createLoopUnrollPass()); // Clean up after the unroller - Passes.add(createInstructionCombiningPass()); + Passes.add(createInstructionCombiningPass()); // GVN for load instructions - Passes.add(createLoadValueNumberingPass()); + Passes.add(createLoadValueNumberingPass()); // Remove common subexprs - Passes.add(createGCSEPass()); + Passes.add(createGCSEPass()); // Constant prop with SCCP Passes.add(createSCCPPass()); } @@ -318,13 +318,13 @@ StackerCompiler::compile( // Run instcombine again after redundancy elimination Passes.add(createInstructionCombiningPass()); // Delete dead stores - Passes.add(createDeadStoreEliminationPass()); + Passes.add(createDeadStoreEliminationPass()); // SSA based 'Aggressive DCE' - Passes.add(createAggressiveDCEPass()); + Passes.add(createAggressiveDCEPass()); // Merge & remove BBs Passes.add(createCFGSimplificationPass()); // Merge dup global constants - Passes.add(createConstantMergePass()); + Passes.add(createConstantMergePass()); } } @@ -342,13 +342,13 @@ StackerCompiler::compile( Passes.run(*TheModule); } catch (...) { - if (F != stdin) fclose(F); // Make sure to close file descriptor + if (F != stdin) fclose(F); // Make sure to close file descriptor throw; // if an exception is thrown } // Close the file if (F != stdin) fclose(F); - + // Return the compiled module to the caller return TheModule; } @@ -369,7 +369,7 @@ StackerCompiler::incr_stack_index( BasicBlock* bb, Value* ival = 0 ) if ( ival == 0 ) ival = One; CastInst* caster = new CastInst( ival, Type::LongTy ); bb->getInstList().push_back( caster ); - BinaryOperator* addop = BinaryOperator::create( Instruction::Add, + BinaryOperator* addop = BinaryOperator::create( Instruction::Add, loadop, caster); bb->getInstList().push_back( addop ); @@ -390,7 +390,7 @@ StackerCompiler::decr_stack_index( BasicBlock* bb, Value* ival = 0 ) if ( ival == 0 ) ival = One; CastInst* caster = new CastInst( ival, Type::LongTy ); bb->getInstList().push_back( caster ); - BinaryOperator* subop = BinaryOperator::create( Instruction::Sub, + BinaryOperator* subop = BinaryOperator::create( Instruction::Sub, loadop, caster); bb->getInstList().push_back( subop ); @@ -404,7 +404,7 @@ StackerCompiler::decr_stack_index( BasicBlock* bb, Value* ival = 0 ) Instruction* StackerCompiler::get_stack_pointer( BasicBlock* bb, Value* index = 0 ) { - // Load the value of the Stack Index + // Load the value of the Stack Index LoadInst* loadop = new LoadInst( TheIndex ); bb->getInstList().push_back( loadop ); @@ -424,7 +424,7 @@ StackerCompiler::get_stack_pointer( BasicBlock* bb, Value* index = 0 ) { CastInst* caster = new CastInst( index, Type::LongTy ); bb->getInstList().push_back( caster ); - BinaryOperator* subop = BinaryOperator::create( + BinaryOperator* subop = BinaryOperator::create( Instruction::Sub, loadop, caster ); bb->getInstList().push_back( subop ); indexVec.push_back(subop); @@ -440,11 +440,11 @@ StackerCompiler::get_stack_pointer( BasicBlock* bb, Value* index = 0 ) Instruction* StackerCompiler::push_value( BasicBlock* bb, Value* val ) { - // Get location of + // Get location of incr_stack_index(bb); // Get the stack pointer - GetElementPtrInst* gep = cast<GetElementPtrInst>( + GetElementPtrInst* gep = cast<GetElementPtrInst>( get_stack_pointer( bb ) ); // Cast the value to a long .. hopefully it works @@ -489,7 +489,7 @@ StackerCompiler::push_string( BasicBlock* bb, const char* value ) // Get length of the string size_t len = strlen( value ); - // Create a type for the string constant. Length is +1 for + // Create a type for the string constant. Length is +1 for // the terminating 0. ArrayType* char_array = ArrayType::get( Type::SByteTy, len + 1 ); @@ -497,10 +497,10 @@ StackerCompiler::push_string( BasicBlock* bb, const char* value ) Constant* initVal = ConstantArray::get( value ); // Create an internal linkage global variable to hold the constant. - GlobalVariable* strconst = new GlobalVariable( - char_array, - /*isConstant=*/true, - GlobalValue::InternalLinkage, + GlobalVariable* strconst = new GlobalVariable( + char_array, + /*isConstant=*/true, + GlobalValue::InternalLinkage, /*initializer=*/initVal, "", TheModule @@ -538,7 +538,7 @@ StackerCompiler::replace_top( BasicBlock* bb, Value* new_top, Value* index = 0 ) // Get the stack pointer GetElementPtrInst* gep = cast<GetElementPtrInst>( get_stack_pointer( bb, index )); - + // Store the value there StoreInst* store_inst = new StoreInst( new_top, gep ); bb->getInstList().push_back( store_inst ); @@ -604,7 +604,7 @@ StackerCompiler::handle_module_start( ) return TheModule; } -Module* +Module* StackerCompiler::handle_module_end( Module* mod ) { // Return the module. @@ -617,7 +617,7 @@ StackerCompiler::handle_definition_list_start() return TheModule; } -Module* +Module* StackerCompiler::handle_definition_list_end( Module* mod, Function* definition ) { if ( ! definition->empty() ) @@ -640,7 +640,7 @@ Function* StackerCompiler::handle_main_definition( Function* func ) { // Set the name of the function defined as the Stacker main - // This will get called by the "main" that is defined in + // This will get called by the "main" that is defined in // the runtime library. func->setName( "_MAIN_"); @@ -656,21 +656,21 @@ StackerCompiler::handle_main_definition( Function* func ) return func; } -Function* +Function* StackerCompiler::handle_forward( char * name ) { // Just create a placeholder function - Function* the_function = new Function ( - DefinitionType, - GlobalValue::ExternalLinkage, - name ); + Function* the_function = new Function ( + DefinitionType, + GlobalValue::ExternalLinkage, + name ); assert( the_function->isExternal() ); free( name ); return the_function; } -Function* +Function* StackerCompiler::handle_definition( char * name, Function* f ) { // Look up the function name in the module to see if it was forward @@ -709,7 +709,7 @@ StackerCompiler::handle_word_list_end( Function* f, BasicBlock* bb ) return f; } -BasicBlock* +BasicBlock* StackerCompiler::handle_if( char* ifTrue, char* ifFalse ) { // Create a basic block for the preamble @@ -718,8 +718,8 @@ StackerCompiler::handle_if( char* ifTrue, char* ifFalse ) // Get the condition value LoadInst* cond = cast<LoadInst>( pop_integer(bb) ); - // Compare the condition against 0 - SetCondInst* cond_inst = new SetCondInst( Instruction::SetNE, cond, + // Compare the condition against 0 + SetCondInst* cond_inst = new SetCondInst( Instruction::SetNE, cond, ConstantSInt::get( Type::LongTy, 0) ); bb->getInstList().push_back( cond_inst ); @@ -734,22 +734,22 @@ StackerCompiler::handle_if( char* ifTrue, char* ifFalse ) if ( ifFalse ) false_bb = new BasicBlock((echo?"else":"")); // Create a branch on the SetCond - BranchInst* br_inst = new BranchInst( true_bb, + BranchInst* br_inst = new BranchInst( true_bb, ( ifFalse ? false_bb : exit_bb ), cond_inst ); bb->getInstList().push_back( br_inst ); - // Fill the true block + // Fill the true block std::vector<Value*> args; if ( Function* true_func = TheModule->getNamedFunction(ifTrue) ) { - true_bb->getInstList().push_back( + true_bb->getInstList().push_back( new CallInst( true_func, args ) ); - true_bb->getInstList().push_back( + true_bb->getInstList().push_back( new BranchInst( exit_bb ) ); } else { - ThrowException(std::string("Function '") + ifTrue + + ThrowException(std::string("Function '") + ifTrue + "' must be declared first.'"); } @@ -760,14 +760,14 @@ StackerCompiler::handle_if( char* ifTrue, char* ifFalse ) { if ( Function* false_func = TheModule->getNamedFunction(ifFalse) ) { - false_bb->getInstList().push_back( + false_bb->getInstList().push_back( new CallInst( false_func, args ) ); - false_bb->getInstList().push_back( + false_bb->getInstList().push_back( new BranchInst( exit_bb ) ); } else { - ThrowException(std::string("Function '") + ifFalse + + ThrowException(std::string("Function '") + ifFalse + "' must be declared first.'"); } free( ifFalse ); @@ -781,7 +781,7 @@ StackerCompiler::handle_if( char* ifTrue, char* ifFalse ) return exit_bb; } -BasicBlock* +BasicBlock* StackerCompiler::handle_while( char* todo ) { @@ -802,8 +802,8 @@ StackerCompiler::handle_while( char* todo ) // Pop the condition value LoadInst* cond = cast<LoadInst>( stack_top(test) ); - // Compare the condition against 0 - SetCondInst* cond_inst = new SetCondInst( + // Compare the condition against 0 + SetCondInst* cond_inst = new SetCondInst( Instruction::SetNE, cond, ConstantSInt::get( Type::LongTy, 0) ); test->getInstList().push_back( cond_inst ); @@ -820,7 +820,7 @@ StackerCompiler::handle_while( char* todo ) } else { - ThrowException(std::string("Function '") + todo + + ThrowException(std::string("Function '") + todo + "' must be declared first.'"); } @@ -834,7 +834,7 @@ StackerCompiler::handle_while( char* todo ) return exit; } -BasicBlock* +BasicBlock* StackerCompiler::handle_identifier( char * name ) { Function* func = TheModule->getNamedFunction( name ); @@ -846,7 +846,7 @@ StackerCompiler::handle_identifier( char * name ) } else { - ThrowException(std::string("Definition '") + name + + ThrowException(std::string("Definition '") + name + "' must be defined before it can be used."); } @@ -854,7 +854,7 @@ StackerCompiler::handle_identifier( char * name ) return bb; } -BasicBlock* +BasicBlock* StackerCompiler::handle_string( char * value ) { // Create a new basic block for the push operation @@ -869,7 +869,7 @@ StackerCompiler::handle_string( char * value ) return bb; } -BasicBlock* +BasicBlock* StackerCompiler::handle_integer( const int64_t value ) { // Create a new basic block for the push operation @@ -881,7 +881,7 @@ StackerCompiler::handle_integer( const int64_t value ) return bb; } -BasicBlock* +BasicBlock* StackerCompiler::handle_word( int tkn ) { // Create a new basic block to hold the instruction(s) @@ -904,13 +904,13 @@ StackerCompiler::handle_word( int tkn ) case TRUETOK : // -- -1 { if (echo) bb->setName("TRUE"); - push_integer(bb,-1); + push_integer(bb,-1); break; } case FALSETOK : // -- 0 { if (echo) bb->setName("FALSE"); - push_integer(bb,0); + push_integer(bb,0); break; } case LESS : // w1 w2 -- w2<w1 @@ -918,7 +918,7 @@ StackerCompiler::handle_word( int tkn ) if (echo) bb->setName("LESS"); LoadInst* op1 = cast<LoadInst>(pop_integer(bb)); LoadInst* op2 = cast<LoadInst>(pop_integer(bb)); - SetCondInst* cond_inst = + SetCondInst* cond_inst = new SetCondInst( Instruction::SetLT, op1, op2 ); bb->getInstList().push_back( cond_inst ); push_value( bb, cond_inst ); @@ -929,7 +929,7 @@ StackerCompiler::handle_word( int tkn ) if (echo) bb->setName("MORE"); LoadInst* op1 = cast<LoadInst>(pop_integer(bb)); LoadInst* op2 = cast<LoadInst>(pop_integer(bb)); - SetCondInst* cond_inst = + SetCondInst* cond_inst = new SetCondInst( Instruction::SetGT, op1, op2 ); bb->getInstList().push_back( cond_inst ); push_value( bb, cond_inst ); @@ -940,7 +940,7 @@ StackerCompiler::handle_word( int tkn ) if (echo) bb->setName("LE"); LoadInst* op1 = cast<LoadInst>(pop_integer(bb)); LoadInst* op2 = cast<LoadInst>(pop_integer(bb)); - SetCondInst* cond_inst = + SetCondInst* cond_inst = new SetCondInst( Instruction::SetLE, op1, op2 ); bb->getInstList().push_back( cond_inst ); push_value( bb, cond_inst ); @@ -951,7 +951,7 @@ StackerCompiler::handle_word( int tkn ) if (echo) bb->setName("GE"); LoadInst* op1 = cast<LoadInst>(pop_integer(bb)); LoadInst* op2 = cast<LoadInst>(pop_integer(bb)); - SetCondInst* cond_inst = + SetCondInst* cond_inst = new SetCondInst( Instruction::SetGE, op1, op2 ); bb->getInstList().push_back( cond_inst ); push_value( bb, cond_inst ); @@ -962,7 +962,7 @@ StackerCompiler::handle_word( int tkn ) if (echo) bb->setName("NE"); LoadInst* op1 = cast<LoadInst>(pop_integer(bb)); LoadInst* op2 = cast<LoadInst>(pop_integer(bb)); - SetCondInst* cond_inst = + SetCondInst* cond_inst = new SetCondInst( Instruction::SetNE, op1, op2 ); bb->getInstList().push_back( cond_inst ); push_value( bb, cond_inst ); @@ -973,7 +973,7 @@ StackerCompiler::handle_word( int tkn ) if (echo) bb->setName("EQ"); LoadInst* op1 = cast<LoadInst>(pop_integer(bb)); LoadInst* op2 = cast<LoadInst>(pop_integer(bb)); - SetCondInst* cond_inst = + SetCondInst* cond_inst = new SetCondInst( Instruction::SetEQ, op1, op2 ); bb->getInstList().push_back( cond_inst ); push_value( bb, cond_inst ); @@ -986,7 +986,7 @@ StackerCompiler::handle_word( int tkn ) if (echo) bb->setName("ADD"); LoadInst* op1 = cast<LoadInst>(pop_integer(bb)); LoadInst* op2 = cast<LoadInst>(pop_integer(bb)); - BinaryOperator* addop = + BinaryOperator* addop = BinaryOperator::create( Instruction::Add, op1, op2); bb->getInstList().push_back( addop ); push_value( bb, addop ); @@ -997,7 +997,7 @@ StackerCompiler::handle_word( int tkn ) if (echo) bb->setName("SUB"); LoadInst* op1 = cast<LoadInst>(pop_integer(bb)); LoadInst* op2 = cast<LoadInst>(pop_integer(bb)); - BinaryOperator* subop = + BinaryOperator* subop = BinaryOperator::create( Instruction::Sub, op1, op2); bb->getInstList().push_back( subop ); push_value( bb, subop ); @@ -1007,7 +1007,7 @@ StackerCompiler::handle_word( int tkn ) { if (echo) bb->setName("INCR"); LoadInst* op1 = cast<LoadInst>(pop_integer(bb)); - BinaryOperator* addop = + BinaryOperator* addop = BinaryOperator::create( Instruction::Add, op1, One ); bb->getInstList().push_back( addop ); push_value( bb, addop ); @@ -1028,7 +1028,7 @@ StackerCompiler::handle_word( int tkn ) if (echo) bb->setName("MUL"); LoadInst* op1 = cast<LoadInst>(pop_integer(bb)); LoadInst* op2 = cast<LoadInst>(pop_integer(bb)); - BinaryOperator* multop = + BinaryOperator* multop = BinaryOperator::create( Instruction::Mul, op1, op2); bb->getInstList().push_back( multop ); push_value( bb, multop ); @@ -1039,7 +1039,7 @@ StackerCompiler::handle_word( int tkn ) if (echo) bb->setName("DIV"); LoadInst* op1 = cast<LoadInst>(pop_integer(bb)); LoadInst* op2 = cast<LoadInst>(pop_integer(bb)); - BinaryOperator* divop = + BinaryOperator* divop = BinaryOperator::create( Instruction::Div, op1, op2); bb->getInstList().push_back( divop ); push_value( bb, divop ); @@ -1050,7 +1050,7 @@ StackerCompiler::handle_word( int tkn ) if (echo) bb->setName("MOD"); LoadInst* op1 = cast<LoadInst>(pop_integer(bb)); LoadInst* op2 = cast<LoadInst>(pop_integer(bb)); - BinaryOperator* divop = + BinaryOperator* divop = BinaryOperator::create( Instruction::Rem, op1, op2); bb->getInstList().push_back( divop ); push_value( bb, divop ); @@ -1065,12 +1065,12 @@ StackerCompiler::handle_word( int tkn ) LoadInst* op3 = cast<LoadInst>(pop_integer(bb)); // Multiply the first two - BinaryOperator* multop = + BinaryOperator* multop = BinaryOperator::create( Instruction::Mul, op1, op2); bb->getInstList().push_back( multop ); // Divide by the third operand - BinaryOperator* divop = + BinaryOperator* divop = BinaryOperator::create( Instruction::Div, multop, op3); bb->getInstList().push_back( divop ); @@ -1100,7 +1100,7 @@ StackerCompiler::handle_word( int tkn ) LoadInst* op1 = cast<LoadInst>(stack_top(bb)); // Determine if its negative - SetCondInst* cond_inst = + SetCondInst* cond_inst = new SetCondInst( Instruction::SetLT, op1, Zero ); bb->getInstList().push_back( cond_inst ); @@ -1140,13 +1140,13 @@ StackerCompiler::handle_word( int tkn ) LoadInst* op1 = cast<LoadInst>(pop_integer(bb)); LoadInst* op2 = cast<LoadInst>(pop_integer(bb)); - // Compare them - SetCondInst* cond_inst = + // Compare them + SetCondInst* cond_inst = new SetCondInst( Instruction::SetLT, op1, op2); bb->getInstList().push_back( cond_inst ); // Create a branch on the SetCond - BranchInst* br_inst = + BranchInst* br_inst = new BranchInst( op1_block, op2_block, cond_inst ); bb->getInstList().push_back( br_inst ); @@ -1172,8 +1172,8 @@ StackerCompiler::handle_word( int tkn ) LoadInst* op1 = cast<LoadInst>(pop_integer(bb)); LoadInst* op2 = cast<LoadInst>(pop_integer(bb)); - // Compare them - SetCondInst* cond_inst = + // Compare them + SetCondInst* cond_inst = new SetCondInst( Instruction::SetGT, op1, op2); bb->getInstList().push_back( cond_inst ); @@ -1191,7 +1191,7 @@ StackerCompiler::handle_word( int tkn ) op2_block->getInstList().push_back( new BranchInst( exit_bb ) ); // Create a banch on the SetCond - BranchInst* br_inst = + BranchInst* br_inst = new BranchInst( op1_block, op2_block, cond_inst ); bb->getInstList().push_back( br_inst ); @@ -1210,7 +1210,7 @@ StackerCompiler::handle_word( int tkn ) if (echo) bb->setName("AND"); LoadInst* op1 = cast<LoadInst>(pop_integer(bb)); LoadInst* op2 = cast<LoadInst>(pop_integer(bb)); - BinaryOperator* andop = + BinaryOperator* andop = BinaryOperator::create( Instruction::And, op1, op2); bb->getInstList().push_back( andop ); push_value( bb, andop ); @@ -1221,7 +1221,7 @@ StackerCompiler::handle_word( int tkn ) if (echo) bb->setName("OR"); LoadInst* op1 = cast<LoadInst>(pop_integer(bb)); LoadInst* op2 = cast<LoadInst>(pop_integer(bb)); - BinaryOperator* orop = + BinaryOperator* orop = BinaryOperator::create( Instruction::Or, op1, op2); bb->getInstList().push_back( orop ); push_value( bb, orop ); @@ -1232,7 +1232,7 @@ StackerCompiler::handle_word( int tkn ) if (echo) bb->setName("XOR"); LoadInst* op1 = cast<LoadInst>(pop_integer(bb)); LoadInst* op2 = cast<LoadInst>(pop_integer(bb)); - BinaryOperator* xorop = + BinaryOperator* xorop = BinaryOperator::create( Instruction::Xor, op1, op2); bb->getInstList().push_back( xorop ); push_value( bb, xorop ); @@ -1264,13 +1264,13 @@ StackerCompiler::handle_word( int tkn ) } // Stack Manipulation Operations - case DROP: // w -- + case DROP: // w -- { if (echo) bb->setName("DROP"); decr_stack_index(bb, One); break; } - case DROP2: // w1 w2 -- + case DROP2: // w1 w2 -- { if (echo) bb->setName("DROP2"); decr_stack_index( bb, Two ); @@ -1417,7 +1417,7 @@ StackerCompiler::handle_word( int tkn ) replace_top( bb, w2, Two ); break; } - case TUCK2: // w1 w2 w3 w4 -- w3 w4 w1 w2 w3 w4 + case TUCK2: // w1 w2 w3 w4 -- w3 w4 w1 w2 w3 w4 { if (echo) bb->setName("TUCK2"); LoadInst* w4 = cast<LoadInst>( stack_top( bb ) ); @@ -1435,10 +1435,10 @@ StackerCompiler::handle_word( int tkn ) } case ROLL: // x0 x1 .. xn n -- x1 .. xn x0 { - /// THIS OEPRATOR IS OMITTED PURPOSEFULLY AND IS LEFT TO THE + /// THIS OEPRATOR IS OMITTED PURPOSEFULLY AND IS LEFT TO THE /// READER AS AN EXERCISE. THIS IS ONE OF THE MORE COMPLICATED /// OPERATORS. IF YOU CAN GET THIS ONE RIGHT, YOU COMPLETELY - /// UNDERSTAND HOW BOTH LLVM AND STACKER WOR. + /// UNDERSTAND HOW BOTH LLVM AND STACKER WOR. /// HINT: LOOK AT PICK AND SELECT. ROLL IS SIMILAR. if (echo) bb->setName("ROLL"); break; @@ -1447,7 +1447,7 @@ StackerCompiler::handle_word( int tkn ) { if (echo) bb->setName("PICK"); LoadInst* n = cast<LoadInst>( stack_top( bb ) ); - BinaryOperator* addop = + BinaryOperator* addop = BinaryOperator::create( Instruction::Add, n, One ); bb->getInstList().push_back( addop ); LoadInst* x0 = cast<LoadInst>( stack_top( bb, addop ) ); @@ -1459,11 +1459,11 @@ StackerCompiler::handle_word( int tkn ) if (echo) bb->setName("SELECT"); LoadInst* m = cast<LoadInst>( stack_top(bb) ); LoadInst* n = cast<LoadInst>( stack_top(bb, One) ); - BinaryOperator* index = + BinaryOperator* index = BinaryOperator::create( Instruction::Add, m, One ); bb->getInstList().push_back( index ); LoadInst* Xm = cast<LoadInst>( stack_top(bb, index ) ); - BinaryOperator* n_plus_1 = + BinaryOperator* n_plus_1 = BinaryOperator::create( Instruction::Add, n, One ); bb->getInstList().push_back( n_plus_1 ); decr_stack_index( bb, n_plus_1 ); @@ -1557,7 +1557,7 @@ StackerCompiler::handle_word( int tkn ) break; } - case RECURSE : + case RECURSE : { if (echo) bb->setName("RECURSE"); std::vector<Value*> params; @@ -1565,13 +1565,13 @@ StackerCompiler::handle_word( int tkn ) bb->getInstList().push_back( call_inst ); break; } - case RETURN : + case RETURN : { if (echo) bb->setName("RETURN"); bb->getInstList().push_back( new ReturnInst() ); break; } - case EXIT : + case EXIT : { if (echo) bb->setName("EXIT"); // Get the result value @@ -1595,12 +1595,12 @@ StackerCompiler::handle_word( int tkn ) std::vector<Value*> indexVec; indexVec.push_back( Zero ); indexVec.push_back( Zero ); - GetElementPtrInst* format_gep = + GetElementPtrInst* format_gep = new GetElementPtrInst( ChrFormat, indexVec ); bb->getInstList().push_back( format_gep ); // Get the character to print (a tab) - ConstantSInt* newline = ConstantSInt::get(Type::IntTy, + ConstantSInt* newline = ConstantSInt::get(Type::IntTy, static_cast<int>('\t')); // Call printf @@ -1610,19 +1610,19 @@ StackerCompiler::handle_word( int tkn ) bb->getInstList().push_back( new CallInst( ThePrintf, args ) ); break; } - case SPACE : + case SPACE : { if (echo) bb->setName("SPACE"); // Get the format string for a character std::vector<Value*> indexVec; indexVec.push_back( Zero ); indexVec.push_back( Zero ); - GetElementPtrInst* format_gep = + GetElementPtrInst* format_gep = new GetElementPtrInst( ChrFormat, indexVec ); bb->getInstList().push_back( format_gep ); // Get the character to print (a space) - ConstantSInt* newline = ConstantSInt::get(Type::IntTy, + ConstantSInt* newline = ConstantSInt::get(Type::IntTy, static_cast<int>(' ')); // Call printf @@ -1632,19 +1632,19 @@ StackerCompiler::handle_word( int tkn ) bb->getInstList().push_back( new CallInst( ThePrintf, args ) ); break; } - case CR : + case CR : { if (echo) bb->setName("CR"); // Get the format string for a character std::vector<Value*> indexVec; indexVec.push_back( Zero ); indexVec.push_back( Zero ); - GetElementPtrInst* format_gep = + GetElementPtrInst* format_gep = new GetElementPtrInst( ChrFormat, indexVec ); bb->getInstList().push_back( format_gep ); // Get the character to print (a newline) - ConstantSInt* newline = ConstantSInt::get(Type::IntTy, + ConstantSInt* newline = ConstantSInt::get(Type::IntTy, static_cast<int>('\n')); // Call printf @@ -1654,19 +1654,19 @@ StackerCompiler::handle_word( int tkn ) bb->getInstList().push_back( new CallInst( ThePrintf, args ) ); break; } - case IN_STR : + case IN_STR : { if (echo) bb->setName("IN_STR"); // Make room for the value result incr_stack_index(bb); - GetElementPtrInst* gep_value = + GetElementPtrInst* gep_value = cast<GetElementPtrInst>(get_stack_pointer(bb)); - CastInst* caster = + CastInst* caster = new CastInst( gep_value, PointerType::get( Type::SByteTy ) ); // Make room for the count result incr_stack_index(bb); - GetElementPtrInst* gep_count = + GetElementPtrInst* gep_count = cast<GetElementPtrInst>(get_stack_pointer(bb)); // Call scanf(3) @@ -1680,17 +1680,17 @@ StackerCompiler::handle_word( int tkn ) bb->getInstList().push_back( new StoreInst( scanf, gep_count ) ); break; } - case IN_NUM : + case IN_NUM : { if (echo) bb->setName("IN_NUM"); // Make room for the value result incr_stack_index(bb); - GetElementPtrInst* gep_value = + GetElementPtrInst* gep_value = cast<GetElementPtrInst>(get_stack_pointer(bb)); // Make room for the count result incr_stack_index(bb); - GetElementPtrInst* gep_count = + GetElementPtrInst* gep_count = cast<GetElementPtrInst>(get_stack_pointer(bb)); // Call scanf(3) @@ -1709,12 +1709,12 @@ StackerCompiler::handle_word( int tkn ) if (echo) bb->setName("IN_CHAR"); // Make room for the value result incr_stack_index(bb); - GetElementPtrInst* gep_value = + GetElementPtrInst* gep_value = cast<GetElementPtrInst>(get_stack_pointer(bb)); // Make room for the count result incr_stack_index(bb); - GetElementPtrInst* gep_count = + GetElementPtrInst* gep_count = cast<GetElementPtrInst>(get_stack_pointer(bb)); // Call scanf(3) @@ -1728,7 +1728,7 @@ StackerCompiler::handle_word( int tkn ) bb->getInstList().push_back( new StoreInst( scanf, gep_count ) ); break; } - case OUT_STR : + case OUT_STR : { if (echo) bb->setName("OUT_STR"); LoadInst* op1 = cast<LoadInst>(stack_top(bb)); @@ -1737,7 +1737,7 @@ StackerCompiler::handle_word( int tkn ) std::vector<Value*> indexVec; indexVec.push_back( Zero ); indexVec.push_back( Zero ); - GetElementPtrInst* format_gep = + GetElementPtrInst* format_gep = new GetElementPtrInst( StrFormat, indexVec ); bb->getInstList().push_back( format_gep ); // Build function call arguments @@ -1748,7 +1748,7 @@ StackerCompiler::handle_word( int tkn ) bb->getInstList().push_back( new CallInst( ThePrintf, args ) ); break; } - case OUT_NUM : + case OUT_NUM : { if (echo) bb->setName("OUT_NUM"); // Pop the numeric operand off the stack @@ -1758,7 +1758,7 @@ StackerCompiler::handle_word( int tkn ) std::vector<Value*> indexVec; indexVec.push_back( Zero ); indexVec.push_back( Zero ); - GetElementPtrInst* format_gep = + GetElementPtrInst* format_gep = new GetElementPtrInst( NumFormat, indexVec ); bb->getInstList().push_back( format_gep ); @@ -1781,7 +1781,7 @@ StackerCompiler::handle_word( int tkn ) std::vector<Value*> indexVec; indexVec.push_back( Zero ); indexVec.push_back( Zero ); - GetElementPtrInst* format_gep = + GetElementPtrInst* format_gep = new GetElementPtrInst( ChrFormat, indexVec ); bb->getInstList().push_back( format_gep ); diff --git a/projects/Stacker/lib/compiler/StackerCompiler.h b/projects/Stacker/lib/compiler/StackerCompiler.h index bf96426..cd48ccb 100644 --- a/projects/Stacker/lib/compiler/StackerCompiler.h +++ b/projects/Stacker/lib/compiler/StackerCompiler.h @@ -1,14 +1,14 @@ //===-- StackerCompiler.h - Interface to the Stacker Compiler ---*- C++ -*-===// -// +// // The LLVM Compiler Infrastructure // -// This file was developed by Reid Spencer and donated to the LLVM research -// group and is distributed under the University of Illinois Open Source +// This file was developed by Reid Spencer and donated to the LLVM research +// group and is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // -// This header file defines the various variables that are shared among the +// This header file defines the various variables that are shared among the // different components of the parser... // //===----------------------------------------------------------------------===// @@ -32,10 +32,10 @@ extern int Stackerlineno; extern char* Stackertext; extern int Stackerleng; -/// @brief This class provides the Compiler for the Stacker language. -/// +/// @brief This class provides the Compiler for the Stacker language. +/// /// The main method to call is \c compile. The other methods are -/// all internal to the compiler and protected. In general the +/// all internal to the compiler and protected. In general the /// handle_* methods are called by the BISON generated parser /// (see StackerParser.y). The methods returning Instruction* all /// produce some snippet of code to manipulate the stack in some @@ -66,7 +66,7 @@ class StackerCompiler /// /// To use the StackerCompiler, just create one on /// the stack and call this method. - Module* compile( + Module* compile( const std::string& filename, ///< File to compile bool echo, ///< Causes compiler to echo output unsigned optLevel, ///< Level of optimization @@ -153,8 +153,8 @@ class StackerCompiler /// @brief Throws an exception to indicate an error /// @param message The message to be output /// @param line Override for the current line no - static inline void ThrowException( const std::string &message, - int line = -1) + static inline void ThrowException( const std::string &message, + int line = -1) { if (line == -1) line = Stackerlineno; // TODO: column number in exception diff --git a/projects/Stacker/tools/stkrc/stkrc.cpp b/projects/Stacker/tools/stkrc/stkrc.cpp index ff61623..34b2820 100644 --- a/projects/Stacker/tools/stkrc/stkrc.cpp +++ b/projects/Stacker/tools/stkrc/stkrc.cpp @@ -1,11 +1,11 @@ //===--- stkrc.cpp --- The Stacker Compiler -------------------------------===// -// +// // The LLVM Compiler Infrastructure // -// This file was developed by Reid Spencer and donated to the LLVM research -// group and is distributed under the University of Illinois Open Source +// This file was developed by Reid Spencer and donated to the LLVM research +// group and is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This is the "main" program for the Stacker Compiler. It is simply a utility @@ -14,7 +14,7 @@ // To get help using this utility, you can invoke it with: // stkrc --help - Output information about command line switches // -// +// //===------------------------------------------------------------------------=== #include "../../lib/compiler/StackerCompiler.h" @@ -29,11 +29,11 @@ using namespace llvm; -static cl::opt<std::string> +static cl::opt<std::string> InputFilename(cl::Positional, cl::desc("<input .st file>"), cl::init("-")); static cl::opt<std::string> -OutputFilename("o", cl::desc("Override output filename"), +OutputFilename("o", cl::desc("Override output filename"), cl::value_desc("filename")); static cl::opt<bool> @@ -46,7 +46,7 @@ StackSize("s", cl::desc("Specify program maximum stack size"), static cl::opt<bool> DumpAsm("d", cl::desc("Print LLVM Assembly as parsed"), cl::Hidden); -#ifdef PARSE_DEBUG +#ifdef PARSE_DEBUG static cl::opt<bool> ParseDebug("g", cl::desc("Turn on Bison Debugging"), cl::Hidden); #endif @@ -81,14 +81,14 @@ static cl::opt<OptLev> OptLevel( clEnumValEnd )); -int main(int argc, char **argv) +int main(int argc, char **argv) { cl::ParseCommandLineOptions(argc, argv, " stacker .st -> .bc compiler\n"); std::ostream *Out = 0; try { StackerCompiler compiler; - try + try { #ifdef PARSE_DEBUG { @@ -103,8 +103,8 @@ int main(int argc, char **argv) } #endif // Parse the file now... - - std::auto_ptr<Module> M ( + + std::auto_ptr<Module> M ( compiler.compile(InputFilename,EchoSource,OptLevel,StackSize)); if (M.get() == 0) { throw std::string("program didn't parse correctly."); @@ -113,8 +113,8 @@ int main(int argc, char **argv) if (verifyModule(*M.get())) { throw std::string("program parsed, but does not verify as correct!"); } - - if (DumpAsm) + + if (DumpAsm) std::cerr << "Here's the assembly:" << M.get(); if (OutputFilename != "") { // Specified an output filename? @@ -128,7 +128,7 @@ int main(int argc, char **argv) } Out = new std::ofstream(OutputFilename.c_str()); } else { // Specified stdout - Out = &std::cout; + Out = &std::cout; } } else { if (InputFilename == "-") { @@ -158,11 +158,11 @@ int main(int argc, char **argv) sys::RemoveFileOnSignal(sys::Path(OutputFilename)); } } - + if (!Out->good()) { throw std::string("error opening ") + OutputFilename + "!"; } - + WriteBytecodeToFile(M.get(), *Out); } catch (const ParseException &E) { std::cerr << argv[0] << ": " << E.getMessage() << "\n"; diff --git a/runtime/GC/GCInterface.h b/runtime/GC/GCInterface.h index e83abe0..4eb4818 100644 --- a/runtime/GC/GCInterface.h +++ b/runtime/GC/GCInterface.h @@ -4,9 +4,9 @@ |* |* This file was developed by the LLVM research group and is distributed under |* the University of Illinois Open Source License. See LICENSE.TXT for details. -|* +|* |*===----------------------------------------------------------------------===*| -|* +|* |* This file defines the common public interface that must be exposed by all |* LLVM garbage collectors. |* diff --git a/runtime/GCCLibraries/crtend/Exception.h b/runtime/GCCLibraries/crtend/Exception.h index 1e51519..9bda39d 100644 --- a/runtime/GCCLibraries/crtend/Exception.h +++ b/runtime/GCCLibraries/crtend/Exception.h @@ -1,10 +1,10 @@ //===- Exception.h - Generic language-independent exceptions ----*- C++ -*-===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file defines the the shared data structures used by all language @@ -24,7 +24,7 @@ struct llvm_exception { // exception type is. // void (*ExceptionDestructor)(llvm_exception *); - + // ExceptionType - This field identifies what runtime library this exception // came from. Currently defined values are: // 0 - Error diff --git a/runtime/GCCLibraries/crtend/SJLJ-Exception.cpp b/runtime/GCCLibraries/crtend/SJLJ-Exception.cpp index 86e0e3a..6a3e472 100644 --- a/runtime/GCCLibraries/crtend/SJLJ-Exception.cpp +++ b/runtime/GCCLibraries/crtend/SJLJ-Exception.cpp @@ -1,10 +1,10 @@ //===- SJLJ-Exception.cpp - SetJmp/LongJmp Exception Handling -------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file implements the API used by the Setjmp/Longjmp exception handling @@ -106,7 +106,7 @@ void __llvm_sjljeh_add_setjmp_to_map(void **SetJmpMap, void *JmpBuf, bool __llvm_sjljeh_is_longjmp_exception() throw() { return __llvm_eh_current_uncaught_exception_type(SJLJException) != 0; } - + // __llvm_sjljeh_get_longjmp_value - This function returns the value that the // setjmp call should "return". This requires that the current uncaught // exception be a sjlj exception, though it does not require the exception to be @@ -125,7 +125,7 @@ int __llvm_sjljeh_get_longjmp_value() throw() { unsigned __llvm_sjljeh_try_catching_longjmp_exception(void **SetJmpMap) throw(){ llvm_sjlj_exception *E = get_sjlj_exception(__llvm_eh_get_uncaught_exception()); - + // Scan for a matching entry in the SetJmpMap... SetJmpMapEntry *SJE = *(SetJmpMapEntry**)SetJmpMap; for (; SJE; SJE = SJE->Next) @@ -140,7 +140,7 @@ unsigned __llvm_sjljeh_try_catching_longjmp_exception(void **SetJmpMap) throw(){ // Return the setjmp ID which we should branch to... return SJE->SetJmpID; } - + // No setjmp in this function catches the exception! return ~0; } diff --git a/runtime/GCCLibraries/crtend/SJLJ-Exception.h b/runtime/GCCLibraries/crtend/SJLJ-Exception.h index eaf927a..ac27cbe 100644 --- a/runtime/GCCLibraries/crtend/SJLJ-Exception.h +++ b/runtime/GCCLibraries/crtend/SJLJ-Exception.h @@ -1,10 +1,10 @@ //===- SJLJ-Exception.h - SetJmp/LongJmp Exception Handling -----*- C++ -*-===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and is distributed under // the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// //===----------------------------------------------------------------------===// // // This file defines the data structures and API used by the Setjmp/Longjmp @@ -61,7 +61,7 @@ extern "C" { // current uncaught exception is a longjmp exception. This is the first step // of catching a sjlj exception. bool __llvm_sjljeh_is_longjmp_exception() throw(); - + // __llvm_sjljeh_get_longjmp_value - This function returns the value that the // setjmp call should "return". This requires that the current uncaught // exception be a sjlj exception, though it does not require the exception to diff --git a/runtime/libprofile/Profiling.h b/runtime/libprofile/Profiling.h index 20f960f..2c40489 100644 --- a/runtime/libprofile/Profiling.h +++ b/runtime/libprofile/Profiling.h @@ -4,9 +4,9 @@ |* |* This file was developed by the LLVM research group and is distributed under |* the University of Illinois Open Source License. See LICENSE.TXT for details. -|* +|* |*===----------------------------------------------------------------------===*| -|* +|* |* This file defines functions shared by the various different profiling |* implementations. |* diff --git a/runtime/libtrace/tracelib.h b/runtime/libtrace/tracelib.h index f700a00..a60697a 100644 --- a/runtime/libtrace/tracelib.h +++ b/runtime/libtrace/tracelib.h @@ -37,4 +37,4 @@ extern void ReleasePointersPopSet(); /*===---------------------------------------------------------------------===*/ -#endif +#endif diff --git a/test/C++Frontend/2003-08-28-ForwardType.cpp b/test/C++Frontend/2003-08-28-ForwardType.cpp index 72f4bc0..4932295 100644 --- a/test/C++Frontend/2003-08-28-ForwardType.cpp +++ b/test/C++Frontend/2003-08-28-ForwardType.cpp @@ -5,9 +5,9 @@ inline void* operator new(unsigned, void* __p) throw(); template<typename _CharT> -struct stdio_filebuf +struct stdio_filebuf { stdio_filebuf(); - + }; extern stdio_filebuf<char> buf_cout; diff --git a/test/C++Frontend/2003-08-28-SaveExprBug.cpp b/test/C++Frontend/2003-08-28-SaveExprBug.cpp index 594ccd4..2be35d8 100644 --- a/test/C++Frontend/2003-08-28-SaveExprBug.cpp +++ b/test/C++Frontend/2003-08-28-SaveExprBug.cpp @@ -6,7 +6,7 @@ char* eback(); template<typename foo> struct basic_filebuf { char *instancevar; - + void callee() { instancevar += eback() != eback(); } diff --git a/test/C++Frontend/2003-08-31-StructLayout.cpp b/test/C++Frontend/2003-08-31-StructLayout.cpp index 21d504c..99d6682 100644 --- a/test/C++Frontend/2003-08-31-StructLayout.cpp +++ b/test/C++Frontend/2003-08-31-StructLayout.cpp @@ -1,6 +1,6 @@ // RUN: %llvmgxx -S %s -o - | llvm-as -f -o /dev/null -// There is a HOLE in the derived2 object due to not wanting to place the two +// There is a HOLE in the derived2 object due to not wanting to place the two // baseclass instances at the same offset! struct baseclass {}; diff --git a/test/C++Frontend/2003-09-30-NestedFunctionDecl.cpp b/test/C++Frontend/2003-09-30-NestedFunctionDecl.cpp index ed7c871..b1c54b8 100644 --- a/test/C++Frontend/2003-09-30-NestedFunctionDecl.cpp +++ b/test/C++Frontend/2003-09-30-NestedFunctionDecl.cpp @@ -1,12 +1,12 @@ // RUN: %llvmgxx -S %s -o - | llvm-as -f -o /dev/null -// The C++ front-end thinks the two foo's are different, the LLVM emitter +// The C++ front-end thinks the two foo's are different, the LLVM emitter // thinks they are the same. The disconnect causes problems. void foo() { } void bar() { void foo(); - + foo(); } diff --git a/test/C++Frontend/2003-10-27-VirtualBaseClassCrash.cpp b/test/C++Frontend/2003-10-27-VirtualBaseClassCrash.cpp index 19cb0cc..f9fc80e 100644 --- a/test/C++Frontend/2003-10-27-VirtualBaseClassCrash.cpp +++ b/test/C++Frontend/2003-10-27-VirtualBaseClassCrash.cpp @@ -7,7 +7,7 @@ struct super { void foo(); }; -template <class T> +template <class T> struct test : virtual super<int> {}; extern test<int> X; diff --git a/test/C++Frontend/2003-11-04-ArrayConstructors.cpp b/test/C++Frontend/2003-11-04-ArrayConstructors.cpp index 8c7c0bf..4df4f9b 100644 --- a/test/C++Frontend/2003-11-04-ArrayConstructors.cpp +++ b/test/C++Frontend/2003-11-04-ArrayConstructors.cpp @@ -1,8 +1,8 @@ // RUN: %llvmgxx -S %s -o - | llvm-as -f -o /dev/null -struct Foo { - Foo(int); +struct Foo { + Foo(int); ~Foo(); }; void foo() { diff --git a/test/C++Frontend/2004-03-15-CleanupsAndGotos.cpp b/test/C++Frontend/2004-03-15-CleanupsAndGotos.cpp index be14b7f..9bc70c8 100644 --- a/test/C++Frontend/2004-03-15-CleanupsAndGotos.cpp +++ b/test/C++Frontend/2004-03-15-CleanupsAndGotos.cpp @@ -8,7 +8,7 @@ struct X { void foo() { X v; - -TryAgain: + +TryAgain: goto TryAgain; } diff --git a/test/C++Frontend/2004-06-08-LateTemplateInstantiation.cpp b/test/C++Frontend/2004-06-08-LateTemplateInstantiation.cpp index 4d31c36..16d8e5e 100644 --- a/test/C++Frontend/2004-06-08-LateTemplateInstantiation.cpp +++ b/test/C++Frontend/2004-06-08-LateTemplateInstantiation.cpp @@ -3,7 +3,7 @@ template<typename Ty> -struct normal_iterator { +struct normal_iterator { int FIELD; }; diff --git a/test/C++Frontend/2005-02-19-UnnamedVirtualThunkArgument.cpp b/test/C++Frontend/2005-02-19-UnnamedVirtualThunkArgument.cpp index e22f30f..853fee7 100644 --- a/test/C++Frontend/2005-02-19-UnnamedVirtualThunkArgument.cpp +++ b/test/C++Frontend/2005-02-19-UnnamedVirtualThunkArgument.cpp @@ -1,22 +1,22 @@ // RUN: %llvmgxx -S %s -o /dev/null -struct Foo { - Foo(); - virtual ~Foo(); -}; - -struct Bar { - Bar(); - virtual ~Bar(); - virtual bool test(bool) const; -}; - -struct Baz : public Foo, public Bar { - Baz(); - virtual ~Baz(); - virtual bool test(bool) const; -}; - -bool Baz::test(bool) const { - return true; -} +struct Foo { + Foo(); + virtual ~Foo(); +}; + +struct Bar { + Bar(); + virtual ~Bar(); + virtual bool test(bool) const; +}; + +struct Baz : public Foo, public Bar { + Baz(); + virtual ~Baz(); + virtual bool test(bool) const; +}; + +bool Baz::test(bool) const { + return true; +} diff --git a/test/C++Frontend/2005-02-20-BrokenReferenceTest.cpp b/test/C++Frontend/2005-02-20-BrokenReferenceTest.cpp index af15f81..31026d3 100644 --- a/test/C++Frontend/2005-02-20-BrokenReferenceTest.cpp +++ b/test/C++Frontend/2005-02-20-BrokenReferenceTest.cpp @@ -3,7 +3,7 @@ void test(unsigned char *b, int rb) { typedef unsigned char imgfoo[10][rb]; imgfoo &br = *(imgfoo *)b; - + br[0][0] = 1; rb = br[0][0]; |