//
//===----------------------------------------------------------------------===//
-#include "llvm/Transforms/LevelChange.h"
+#include "llvm/Transforms/RaisePointerReferences.h"
#include "llvm/Transforms/Utils/Local.h"
#include "TransformInternals.h"
#include "llvm/iOther.h"
#include "llvm/Analysis/Verifier.h"
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
#include "Support/STLExtras.h"
-#include "Support/StatisticReporter.h"
+#include "Support/Statistic.h"
#include "Support/CommandLine.h"
#include <algorithm>
using std::cerr;
// raising pass to start at instruction "foo", which is immensely useful for
// debugging!
//
-static cl::String StartInst("raise-start-inst", "Start raise pass at the "
- "instruction with the specified name", cl::Hidden);
+static cl::opt<std::string>
+StartInst("raise-start-inst", cl::Hidden, cl::value_desc("inst name"),
+ cl::desc("Start raise pass at the instruction with the specified name"));
-static Statistic<> NumLoadStorePeepholes("raise\t\t- Number of load/store "
- "peepholes");
-static Statistic<> NumGEPInstFormed("raise\t\t- Number of other "
- "getelementptr's formed");
-static Statistic<> NumExprTreesConv("raise\t\t- Number of expression trees"
- " converted");
-static Statistic<> NumCastOfCast("raise\t\t- Number of cast-of-self removed");
-static Statistic<> NumDCEorCP("raise\t\t- Number of insts DCEd or constprop'd");
+static Statistic<>
+NumLoadStorePeepholes("raise", "Number of load/store peepholes");
+
+static Statistic<>
+NumGEPInstFormed("raise", "Number of other getelementptr's formed");
+
+static Statistic<>
+NumExprTreesConv("raise", "Number of expression trees converted");
+
+static Statistic<>
+NumCastOfCast("raise", "Number of cast-of-self removed");
+
+static Statistic<>
+NumDCEorCP("raise", "Number of insts DCEd or constprop'd");
+
+static Statistic<>
+NumVarargCallChanges("raise", "Number of vararg call peepholes");
#define PRINT_PEEPHOLE(ID, NUM, I) \
Value *AddOp1, CastInst *AddOp2) {
const CompositeType *CompTy;
Value *OffsetVal = AddOp2->getOperand(0);
- Value *SrcPtr; // Of type pointer to struct...
+ Value *SrcPtr = 0; // Of type pointer to struct...
if ((CompTy = getPointedToComposite(AddOp1->getType()))) {
SrcPtr = AddOp1; // Handle the first case...
}
// Only proceed if we have detected all of our conditions successfully...
- if (!CompTy || !SrcPtr || !OffsetVal->getType()->isIntegral())
+ if (!CompTy || !SrcPtr || !OffsetVal->getType()->isInteger())
return false;
std::vector<Value*> Indices;
}
GetElementPtrInst *GEP = new GetElementPtrInst(SrcPtr, Indices,
- AddOp2->getName());
- BI = ++BB->getInstList().insert(BI, GEP);
+ AddOp2->getName(), BI);
Instruction *NCI = new CastInst(GEP, AddOp1->getType());
ReplaceInstWithInst(BB->getInstList(), BI, NCI);
if (!Src->hasName() && CI->hasName()) {
std::string Name = CI->getName();
CI->setName("");
- Src->setName(Name, BB->getParent()->getSymbolTable());
+ Src->setName(Name, &BB->getParent()->getSymbolTable());
}
// DCE the instruction now, to avoid having the iterative version of DCE
// source type of the cast...
//
ConvertedTypes.clear();
- ConvertedTypes[Src] = Src->getType(); // Make sure the source doesn't change type
+ // Make sure the source doesn't change type
+ ConvertedTypes[Src] = Src->getType();
if (ValueConvertableToType(CI, Src->getType(), ConvertedTypes)) {
PRINT_PEEPHOLE3("CAST-DEST-EXPR-CONV:in ", Src, CI, BB->getParent());
// Build the index vector, full of all zeros
std::vector<Value*> Indices;
- Indices.push_back(ConstantUInt::get(Type::UIntTy, 0));
+ Indices.push_back(ConstantSInt::get(Type::LongTy, 0));
while (CurCTy && !isa<PointerType>(CurCTy)) {
if (const StructType *CurSTy = dyn_cast<StructType>(CurCTy)) {
// Check for a zero element struct type... if we have one, bail.
}
// Insert a zero to index through this type...
- Indices.push_back(ConstantUInt::get(CurCTy->getIndexType(), 0));
+ Indices.push_back(Constant::getNullValue(CurCTy->getIndexType()));
// Did we find what we're looking for?
if (ElTy->isLosslesslyConvertableTo(DestPointedTy)) break;
if (ElTy) {
PRINT_PEEPHOLE1("cast-for-first:in", CI);
+ std::string Name = CI->getName(); CI->setName("");
+
// Insert the new T cast instruction... stealing old T's name
GetElementPtrInst *GEP = new GetElementPtrInst(Src, Indices,
- CI->getName());
- CI->setName("");
- BI = ++BB->getInstList().insert(BI, GEP);
+ Name, BI);
// Make the old cast instruction reference the new GEP instead of
// the old src value.
if (Value *CastSrc = CI->getOperand(0)) // CSPT = CastSrcPointerType
if (const PointerType *CSPT = dyn_cast<PointerType>(CastSrc->getType()))
// convertable types?
- if (Val->getType()->isLosslesslyConvertableTo(CSPT->getElementType()) &&
- !SI->hasIndices()) { // No subscripts yet!
+ if (Val->getType()->isLosslesslyConvertableTo(CSPT->getElementType())) {
PRINT_PEEPHOLE3("st-src-cast:in ", Pointer, Val, SI);
// Insert the new T cast instruction... stealing old T's name
+ std::string Name(CI->getName()); CI->setName("");
CastInst *NCI = new CastInst(Val, CSPT->getElementType(),
- CI->getName());
- CI->setName("");
- BI = ++BB->getInstList().insert(BI, NCI);
+ Name, BI);
// Replace the old store with a new one!
ReplaceInstWithInst(BB->getInstList(), BI,
if (Value *CastSrc = CI->getOperand(0)) // CSPT = CastSrcPointerType
if (const PointerType *CSPT = dyn_cast<PointerType>(CastSrc->getType()))
// convertable types?
- if (PtrElType->isLosslesslyConvertableTo(CSPT->getElementType()) &&
- !LI->hasIndices()) { // No subscripts yet!
+ if (PtrElType->isLosslesslyConvertableTo(CSPT->getElementType())) {
PRINT_PEEPHOLE2("load-src-cast:in ", Pointer, LI);
// Create the new load instruction... loading the pre-casted value
- LoadInst *NewLI = new LoadInst(CastSrc, LI->getName());
+ 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());
- BI = ++BB->getInstList().insert(BI, NewLI);
// Replace the old store with a new one!
ReplaceInstWithInst(BB->getInstList(), BI, NCI);
++NumGEPInstFormed;
return true;
}
+ } else if (CallInst *CI = dyn_cast<CallInst>(I)) {
+ // If we have a call with all varargs arguments, convert the call to use the
+ // actual argument types present...
+ //
+ const PointerType *PTy = cast<PointerType>(CI->getCalledValue()->getType());
+ const FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
+
+ // Is the call to a vararg variable with no real parameters?
+ if (FTy->isVarArg() && FTy->getNumParams() == 0) {
+ // If so, insert a new cast instruction, casting it to a function type
+ // that matches the current arguments...
+ //
+ std::vector<const Type *> Params; // Parameter types...
+ for (unsigned i = 1, e = CI->getNumOperands(); i != e; ++i)
+ Params.push_back(CI->getOperand(i)->getType());
+
+ FunctionType *NewFT = FunctionType::get(FTy->getReturnType(),
+ Params, false);
+ PointerType *NewPFunTy = PointerType::get(NewFT);
+
+ // Create a new cast, inserting it right before the function call...
+ CastInst *NewCast = new CastInst(CI->getCalledValue(), NewPFunTy,
+ CI->getCalledValue()->getName(), CI);
+
+ // Create a new call instruction...
+ CallInst *NewCall = new CallInst(NewCast,
+ std::vector<Value*>(CI->op_begin()+1, CI->op_end()));
+ ++BI;
+ ReplaceInstWithInst(CI, NewCall);
+
+ ++NumVarargCallChanges;
+ return true;
+ }
+
}
return false;
if (dceInstruction(BI) || doConstantPropogation(BI)) {
Changed = true;
++NumDCEorCP;
- DEBUG(cerr << "***\t\t^^-- DeadCode Elinated!\n");
+ DEBUG(cerr << "***\t\t^^-- Dead code eliminated!\n");
} else if (PeepholeOptimize(BB, BI)) {
Changed = true;
} else {
namespace {
struct RaisePointerReferences : public FunctionPass {
- const char *getPassName() const { return "Raise Pointer References"; }
+
+ // FIXME: constructor should save and use target data here!!
+ RaisePointerReferences(const TargetData &TD) {}
virtual bool runOnFunction(Function &F) { return doRPR(F); }
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
- AU.preservesCFG();
+ AU.setPreservesCFG();
}
};
}
-Pass *createRaisePointerReferencesPass() {
- return new RaisePointerReferences();
+Pass *createRaisePointerReferencesPass(const TargetData &TD) {
+ return new RaisePointerReferences(TD);
}
-
+static RegisterOpt<RaisePointerReferences>
+X("raise", "Raise Pointer References", createRaisePointerReferencesPass);
projects / oota-llvm.git / blobdiff