aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--include/llvm/InitializePasses.h1
-rw-r--r--include/llvm/Transforms/NaCl.h4
-rw-r--r--lib/IR/Constants.cpp2
-rw-r--r--lib/Transforms/NaCl/CMakeLists.txt1
-rw-r--r--lib/Transforms/NaCl/ExpandUtils.cpp5
-rw-r--r--lib/Transforms/NaCl/ExpandVarArgs.cpp5
-rw-r--r--lib/Transforms/NaCl/ReplacePtrsWithInts.cpp557
-rw-r--r--test/Transforms/NaCl/replace-ptrs-with-ints.ll511
-rw-r--r--tools/opt/opt.cpp1
9 files changed, 1081 insertions, 6 deletions
diff --git a/include/llvm/InitializePasses.h b/include/llvm/InitializePasses.h
index bde46f413f..bd385de931 100644
--- a/include/llvm/InitializePasses.h
+++ b/include/llvm/InitializePasses.h
@@ -291,6 +291,7 @@ void initializeNaClCcRewritePass(PassRegistry&);
void initializePNaClABIVerifyModulePass(PassRegistry&);
void initializePNaClABIVerifyFunctionsPass(PassRegistry&);
void initializePromoteIntegersPass(PassRegistry&);
+void initializeReplacePtrsWithIntsPass(PassRegistry&);
void initializeResolveAliasesPass(PassRegistry&);
void initializeRewritePNaClLibraryCallsPass(PassRegistry&);
void initializeStripMetadataPass(PassRegistry&);
diff --git a/include/llvm/Transforms/NaCl.h b/include/llvm/Transforms/NaCl.h
index b2c012f08d..c324fa8c0c 100644
--- a/include/llvm/Transforms/NaCl.h
+++ b/include/llvm/Transforms/NaCl.h
@@ -29,6 +29,7 @@ ModulePass *createExpandVarArgsPass();
ModulePass *createFlattenGlobalsPass();
ModulePass *createGlobalCleanupPass();
FunctionPass *createPromoteIntegersPass();
+ModulePass *createReplacePtrsWithIntsPass();
ModulePass *createResolveAliasesPass();
ModulePass *createRewritePNaClLibraryCallsPass();
ModulePass *createStripMetadataPass();
@@ -37,6 +38,9 @@ FunctionPass *createInsertDivideCheckPass();
Instruction *PhiSafeInsertPt(Use *U);
void PhiSafeReplaceUses(Use *U, Value *NewVal);
+// Copy debug information from Original to NewInst, and return NewInst.
+Instruction *CopyDebug(Instruction *NewInst, Instruction *Original);
+
}
#endif
diff --git a/lib/IR/Constants.cpp b/lib/IR/Constants.cpp
index 8093a09749..027946efd1 100644
--- a/lib/IR/Constants.cpp
+++ b/lib/IR/Constants.cpp
@@ -1371,7 +1371,7 @@ void BlockAddress::replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U) {
BasicBlock *NewBB = getBasicBlock();
if (U == &Op<0>())
- NewF = cast<Function>(To);
+ NewF = cast<Function>(To->stripPointerCasts()); // @LOCALMOD
else
NewBB = cast<BasicBlock>(To);
diff --git a/lib/Transforms/NaCl/CMakeLists.txt b/lib/Transforms/NaCl/CMakeLists.txt
index 95b14f7fa9..d289c8912f 100644
--- a/lib/Transforms/NaCl/CMakeLists.txt
+++ b/lib/Transforms/NaCl/CMakeLists.txt
@@ -11,6 +11,7 @@ add_llvm_library(LLVMNaClTransforms
FlattenGlobals.cpp
GlobalCleanup.cpp
PromoteIntegers.cpp
+ ReplacePtrsWithInts.cpp
RewritePNaClLibraryCalls.cpp
StripMetadata.cpp
)
diff --git a/lib/Transforms/NaCl/ExpandUtils.cpp b/lib/Transforms/NaCl/ExpandUtils.cpp
index 0670ff75ce..507760603f 100644
--- a/lib/Transforms/NaCl/ExpandUtils.cpp
+++ b/lib/Transforms/NaCl/ExpandUtils.cpp
@@ -38,3 +38,8 @@ void llvm::PhiSafeReplaceUses(Use *U, Value *NewVal) {
U->getUser()->replaceUsesOfWith(U->get(), NewVal);
}
}
+
+Instruction *llvm::CopyDebug(Instruction *NewInst, Instruction *Original) {
+ NewInst->setDebugLoc(Original->getDebugLoc());
+ return NewInst;
+}
diff --git a/lib/Transforms/NaCl/ExpandVarArgs.cpp b/lib/Transforms/NaCl/ExpandVarArgs.cpp
index 1932107b4c..3ea093f8f8 100644
--- a/lib/Transforms/NaCl/ExpandVarArgs.cpp
+++ b/lib/Transforms/NaCl/ExpandVarArgs.cpp
@@ -65,11 +65,6 @@ INITIALIZE_PASS(ExpandVarArgs, "expand-varargs",
"Expand out variable argument function definitions and calls",
false, false)
-static Instruction *CopyDebug(Instruction *NewInst, Instruction *Original) {
- NewInst->setDebugLoc(Original->getDebugLoc());
- return NewInst;
-}
-
static void ExpandVarArgFunc(Function *Func) {
Type *PtrType = Type::getInt8PtrTy(Func->getContext());
diff --git a/lib/Transforms/NaCl/ReplacePtrsWithInts.cpp b/lib/Transforms/NaCl/ReplacePtrsWithInts.cpp
new file mode 100644
index 0000000000..4ca5b59e00
--- /dev/null
+++ b/lib/Transforms/NaCl/ReplacePtrsWithInts.cpp
@@ -0,0 +1,557 @@
+//===- ReplacePtrsWithInts.cpp - Convert pointer values to integer values--===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This pass strips out aggregate pointer types and replaces them with
+// the integer type iPTR, which is i32 for PNaCl (though this pass
+// will allow iPTR to be i64 if the DataLayout specifies 64-bit
+// pointers).
+//
+// The pass converts IR to the following normal form:
+//
+// All inttoptr and ptrtoint instructions use the same integer size
+// (iPTR), so they do not implicitly truncate or zero-extend.
+//
+// alloca always allocates an i8 array type.
+//
+// Pointer types only appear in the following instructions:
+// * loads and stores: the pointer operand is a NormalizedPtr.
+// * function calls: the function operand is a NormalizedPtr.
+// * intrinsic calls: any pointer arguments are NormalizedPtrs.
+// * alloca
+// * bitcast and inttoptr: only used as part of a NormalizedPtr.
+// * ptrtoint: the operand is an InherentPtr.
+//
+// Where an InherentPtr is defined as a pointer value that is:
+// * an alloca;
+// * a GlobalValue (a function or global variable); or
+// * an intrinsic call.
+//
+// And a NormalizedPtr is defined as a pointer value that is:
+// * an inttoptr instruction;
+// * an InherentPtr; or
+// * a bitcast of an InherentPtr.
+//
+// This pass currently strips out lifetime markers (that is, calls to
+// the llvm.lifetime.start/end intrinsics).
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/IR/DataLayout.h"
+#include "llvm/IR/DerivedTypes.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/IR/IntrinsicInst.h"
+#include "llvm/IR/Module.h"
+#include "llvm/IR/Type.h"
+#include "llvm/Pass.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/Transforms/NaCl.h"
+
+using namespace llvm;
+
+namespace {
+ // This is a ModulePass because the pass must recreate functions in
+ // order to change their argument and return types.
+ struct ReplacePtrsWithInts : public ModulePass {
+ static char ID; // Pass identification, replacement for typeid
+ ReplacePtrsWithInts() : ModulePass(ID) {
+ initializeReplacePtrsWithIntsPass(*PassRegistry::getPassRegistry());
+ }
+
+ virtual bool runOnModule(Module &M);
+ };
+
+ // FunctionConverter stores the state for mapping old instructions
+ // (of pointer type) to converted instructions (of integer type)
+ // within a function, and provides methods for doing the conversion.
+ class FunctionConverter {
+ // Int type that pointer types are to be replaced with, typically i32.
+ Type *IntPtrType;
+
+ struct RewrittenVal {
+ RewrittenVal(): IsPlaceholder(true), NewIntVal(NULL) {}
+ bool IsPlaceholder;
+ Value *NewIntVal;
+ };
+ // Maps from old values (of pointer type) to converted values (of
+ // IntPtrType type).
+ DenseMap<Value *, RewrittenVal> RewriteMap;
+ // Number of placeholders; used for detecting unhandled cases.
+ int PlaceholderCount;
+ // List of instructions whose deletion has been deferred.
+ SmallVector<Instruction *, 20> ToErase;
+
+ public:
+ FunctionConverter(Type *IntPtrType)
+ : IntPtrType(IntPtrType), PlaceholderCount(0) {}
+
+ // Returns the normalized version of the given type, converting
+ // pointer types to IntPtrType.
+ Type *convertType(Type *Ty);
+ // Returns the normalized version of the given function type by
+ // normalizing the function's argument types.
+ FunctionType *convertFuncType(FunctionType *FTy);
+
+ // Records that 'To' is the normalized version of 'From'. If 'To'
+ // is not of pointer type, no type conversion is required, so this
+ // can take the short cut of replacing 'To' with 'From'.
+ void recordConverted(Value *From, Value *To);
+ void recordConvertedAndErase(Instruction *From, Value *To);
+
+ // Returns the normalized version of the given value.
+ Value *convert(Value *Val);
+ // Returns the NormalizedPtr form of the given pointer value.
+ // Inserts conversion instructions at InsertPt.
+ Value *convertBackToPtr(Value *Val, Instruction *InsertPt);
+ // Returns the NormalizedPtr form of the given function pointer.
+ // Inserts conversion instructions at InsertPt.
+ Value *convertFunctionPtr(Value *Callee, Instruction *InsertPt);
+ // Converts an instruction without recreating it, by wrapping its
+ // operands and result.
+ void convertInPlace(Instruction *Inst);
+
+ void eraseReplacedInstructions();
+ };
+}
+
+Type *FunctionConverter::convertType(Type *Ty) {
+ if (Ty->isPointerTy())
+ return IntPtrType;
+ return Ty;
+}
+
+FunctionType *FunctionConverter::convertFuncType(FunctionType *FTy) {
+ SmallVector<Type *, 8> ArgTypes;
+ for (FunctionType::param_iterator ArgTy = FTy->param_begin(),
+ E = FTy->param_end(); ArgTy != E; ++ArgTy) {
+ ArgTypes.push_back(convertType(*ArgTy));
+ }
+ return FunctionType::get(convertType(FTy->getReturnType()), ArgTypes,
+ FTy->isVarArg());
+}
+
+void FunctionConverter::recordConverted(Value *From, Value *To) {
+ if (!From->getType()->isPointerTy()) {
+ From->replaceAllUsesWith(To);
+ return;
+ }
+ RewrittenVal *RV = &RewriteMap[From];
+ if (RV->NewIntVal) {
+ assert(RV->IsPlaceholder);
+ // Resolve placeholder.
+ RV->NewIntVal->replaceAllUsesWith(To);
+ delete RV->NewIntVal;
+ RV->IsPlaceholder = false;
+ --PlaceholderCount;
+ }
+ RV->NewIntVal = To;
+}
+
+void FunctionConverter::recordConvertedAndErase(Instruction *From, Value *To) {
+ recordConverted(From, To);
+ // There may still be references to this value, so defer deleting it.
+ ToErase.push_back(From);
+}
+
+Value *FunctionConverter::convert(Value *Val) {
+ if (!Val->getType()->isPointerTy())
+ return Val;
+ if (Constant *C = dyn_cast<Constant>(Val))
+ return ConstantExpr::getPtrToInt(C, IntPtrType);
+ RewrittenVal *RV = &RewriteMap[Val];
+ if (!RV->NewIntVal) {
+ // No converted value available yet, so create a placeholder.
+ Argument *Placeholder = new Argument(convertType(Val->getType()));
+ RV->NewIntVal = Placeholder;
+ ++PlaceholderCount;
+ }
+ return RV->NewIntVal;
+}
+
+Value *FunctionConverter::convertBackToPtr(Value *Val, Instruction *InsertPt) {
+ Type *NewTy =
+ convertType(Val->getType()->getPointerElementType())->getPointerTo();
+ Value *Conv = convert(Val);
+ return new IntToPtrInst(Conv, NewTy, Conv->getName() + ".asptr", InsertPt);
+}
+
+Value *FunctionConverter::convertFunctionPtr(Value *Callee,
+ Instruction *InsertPt) {
+ FunctionType *FuncType = cast<FunctionType>(
+ Callee->getType()->getPointerElementType());
+ Value *Conv = convert(Callee);
+ return new IntToPtrInst(Conv, convertFuncType(FuncType)->getPointerTo(),
+ Conv->getName() + ".asfuncptr", InsertPt);
+}
+
+static bool ShouldLeaveAlone(Value *V) {
+ if (Function *F = dyn_cast<Function>(V))
+ return F->isIntrinsic();
+ if (isa<InlineAsm>(V))
+ return true;
+ return false;
+}
+
+void FunctionConverter::convertInPlace(Instruction *Inst) {
+ // Convert operands.
+ for (unsigned I = 0; I < Inst->getNumOperands(); ++I) {
+ Value *Arg = Inst->getOperand(I);
+ if (Arg->getType()->isPointerTy() && !ShouldLeaveAlone(Arg)) {
+ Value *Conv = convert(Arg);
+ Inst->setOperand(I, new IntToPtrInst(convert(Arg), Arg->getType(),
+ Conv->getName() + ".asptr", Inst));
+ }
+ }
+ // Convert result.
+ if (Inst->getType()->isPointerTy()) {
+ Instruction *Cast = new PtrToIntInst(
+ Inst, convertType(Inst->getType()), Inst->getName() + ".asint");
+ Cast->insertAfter(Inst);
+ recordConverted(Inst, Cast);
+ }
+}
+
+void FunctionConverter::eraseReplacedInstructions() {
+ if (PlaceholderCount) {
+ for (DenseMap<Value *, RewrittenVal>::iterator I = RewriteMap.begin(),
+ E = RewriteMap.end(); I != E; ++I) {
+ if (I->second.IsPlaceholder)
+ errs() << "Not converted: " << *I->first << "\n";
+ }
+ report_fatal_error("Case not handled in ReplacePtrsWithInts");
+ }
+ // We must do dropAllReferences() before doing eraseFromParent(),
+ // otherwise we will try to erase instructions that are still
+ // referenced.
+ for (SmallVectorImpl<Instruction *>::iterator I = ToErase.begin(),
+ E = ToErase.end();
+ I != E; ++I) {
+ (*I)->dropAllReferences();
+ }
+ for (SmallVectorImpl<Instruction *>::iterator I = ToErase.begin(),
+ E = ToErase.end();
+ I != E; ++I) {
+ (*I)->eraseFromParent();
+ }
+}
+
+static void ConvertMetadataOperand(FunctionConverter *FC,
+ IntrinsicInst *Call, int Index) {
+ MDNode *MD = cast<MDNode>(Call->getArgOperand(Index));
+ if (MD->getNumOperands() != 1)
+ return;
+ Value *MDArg = MD->getOperand(0);
+ if (MDArg && (isa<Argument>(MDArg) || isa<Instruction>(MDArg))) {
+ MDArg = FC->convert(MDArg);
+ if (PtrToIntInst *Cast = dyn_cast<PtrToIntInst>(MDArg)) {
+ // Unwrapping this is necessary for llvm.dbg.declare to work.
+ MDArg = Cast->getPointerOperand();
+ }
+ SmallVector<Value *, 1> Args;
+ Args.push_back(MDArg);
+ Call->setArgOperand(Index, MDNode::get(Call->getContext(), Args));
+ }
+}
+
+// Remove attributes that only apply to pointer arguments. Returns
+// the updated AttributeSet.
+static AttributeSet RemovePointerAttrs(LLVMContext &Context,
+ AttributeSet Attrs) {
+ SmallVector<AttributeSet, 8> AttrList;
+ for (unsigned Slot = 0; Slot < Attrs.getNumSlots(); ++Slot) {
+ unsigned Index = Attrs.getSlotIndex(Slot);
+ AttrBuilder AB;
+ for (AttributeSet::iterator Attr = Attrs.begin(Slot), E = Attrs.end(Slot);
+ Attr != E; ++Attr) {
+ switch (Attr->getKindAsEnum()) {
+ // ByVal and StructRet should already have been removed by the
+ // ExpandByVal pass.
+ case Attribute::ByVal:
+ case Attribute::StructRet:
+ case Attribute::Nest:
+ Attrs.dump();
+ report_fatal_error("ReplacePtrsWithInts cannot handle "
+ "byval, sret or nest attrs");
+ break;
+ // Strip NoCapture and NoAlias because they are only allowed
+ // on arguments of pointer type, and we are removing the
+ // pointer types.
+ case Attribute::NoCapture:
+ case Attribute::NoAlias:
+ break;
+ default:
+ AB.addAttribute(*Attr);
+ }
+ }
+ AttrList.push_back(AttributeSet::get(Context, Index, AB));
+ }
+ return AttributeSet::get(Context, AttrList);
+}
+
+template <class InstType>
+static void CopyLoadOrStoreAttrs(InstType *Dest, InstType *Src) {
+ Dest->setVolatile(Src->isVolatile());
+ Dest->setAlignment(Src->getAlignment());
+ Dest->setOrdering(Src->getOrdering());
+ Dest->setSynchScope(Src->getSynchScope());
+}
+
+static void ConvertInstruction(DataLayout *DL, Type *IntPtrType,
+ FunctionConverter *FC, Instruction *Inst) {
+ if (ReturnInst *Ret = dyn_cast<ReturnInst>(Inst)) {
+ Value *Result = Ret->getReturnValue();
+ if (Result)
+ Result = FC->convert(Result);
+ CopyDebug(ReturnInst::Create(Ret->getContext(), Result, Ret), Inst);
+ Ret->eraseFromParent();
+ } else if (PHINode *Phi = dyn_cast<PHINode>(Inst)) {
+ PHINode *Phi2 = PHINode::Create(FC->convertType(Phi->getType()),
+ Phi->getNumIncomingValues(),
+ "", Phi);
+ CopyDebug(Phi2, Phi);
+ for (unsigned I = 0; I < Phi->getNumIncomingValues(); ++I) {
+ Phi2->addIncoming(FC->convert(Phi->getIncomingValue(I)),
+ Phi->getIncomingBlock(I));
+ }
+ Phi2->takeName(Phi);
+ FC->recordConvertedAndErase(Phi, Phi2);
+ } else if (SelectInst *Op = dyn_cast<SelectInst>(Inst)) {
+ Instruction *Op2 = SelectInst::Create(Op->getCondition(),
+ FC->convert(Op->getTrueValue()),
+ FC->convert(Op->getFalseValue()),
+ "", Op);
+ CopyDebug(Op2, Op);
+ Op2->takeName(Op);
+ FC->recordConvertedAndErase(Op, Op2);
+ } else if (isa<PtrToIntInst>(Inst) || isa<IntToPtrInst>(Inst)) {
+ Value *Arg = FC->convert(Inst->getOperand(0));
+ Type *ResultTy = FC->convertType(Inst->getType());
+ IRBuilder<> Builder(Inst);
+ Builder.SetCurrentDebugLocation(Inst->getDebugLoc());
+ Value *Result = Builder.CreateZExtOrTrunc(Arg, ResultTy, "");
+ if (Result != Arg)
+ Result->takeName(Inst);
+ FC->recordConvertedAndErase(Inst, Result);
+ } else if (isa<BitCastInst>(Inst)) {
+ if (Inst->getType()->isPointerTy()) {
+ FC->recordConvertedAndErase(Inst, FC->convert(Inst->getOperand(0)));
+ }
+ } else if (ICmpInst *Cmp = dyn_cast<ICmpInst>(Inst)) {
+ Value *Cmp2 = CopyDebug(new ICmpInst(Inst, Cmp->getPredicate(),
+ FC->convert(Cmp->getOperand(0)),
+ FC->convert(Cmp->getOperand(1)), ""),
+ Inst);
+ Cmp2->takeName(Cmp);
+ Cmp->replaceAllUsesWith(Cmp2);
+ Cmp->eraseFromParent();
+ } else if (LoadInst *Load = dyn_cast<LoadInst>(Inst)) {
+ Value *Ptr = FC->convertBackToPtr(Load->getPointerOperand(), Inst);
+ LoadInst *Result = new LoadInst(Ptr, "", Inst);
+ Result->takeName(Inst);
+ CopyDebug(Result, Inst);
+ CopyLoadOrStoreAttrs(Result, Load);
+ FC->recordConvertedAndErase(Inst, Result);
+ } else if (StoreInst *Store = dyn_cast<StoreInst>(Inst)) {
+ Value *Ptr = FC->convertBackToPtr(Store->getPointerOperand(), Inst);
+ StoreInst *Result = new StoreInst(FC->convert(Store->getValueOperand()),
+ Ptr, Inst);
+ CopyDebug(Result, Inst);
+ CopyLoadOrStoreAttrs(Result, Store);
+ Inst->eraseFromParent();
+ } else if (CallInst *Call = dyn_cast<CallInst>(Inst)) {
+ if (IntrinsicInst *ICall = dyn_cast<IntrinsicInst>(Inst)) {
+ if (ICall->getIntrinsicID() == Intrinsic::lifetime_start ||
+ ICall->getIntrinsicID() == Intrinsic::lifetime_end) {
+ // Remove alloca lifetime markers for now. This is because
+ // the GVN pass can introduce lifetime markers taking PHI
+ // nodes as arguments. If ReplacePtrsWithInts converts the
+ // PHI node to int type, we will render those lifetime markers
+ // ineffective. But dropping a subset of lifetime markers is
+ // not safe in general. So, until LLVM better defines the
+ // semantics of lifetime markers, we drop them all. See:
+ // https://code.google.com/p/nativeclient/issues/detail?id=3443
+ Inst->eraseFromParent();
+ } else {
+ if (ICall->getIntrinsicID() == Intrinsic::dbg_declare) {
+ ConvertMetadataOperand(FC, ICall, 0);
+ }
+ FC->convertInPlace(Inst);
+ }
+ } else if (isa<InlineAsm>(Call->getCalledValue())) {
+ FC->convertInPlace(Inst);
+ } else {
+ SmallVector<Value *, 10> Args;
+ for (unsigned I = 0; I < Call->getNumArgOperands(); ++I)
+ Args.push_back(FC->convert(Call->getArgOperand(I)));
+ CallInst *NewCall = CallInst::Create(
+ FC->convertFunctionPtr(Call->getCalledValue(), Call),
+ Args, "", Inst);
+ CopyDebug(NewCall, Call);
+ NewCall->setAttributes(RemovePointerAttrs(Call->getContext(),
+ Call->getAttributes()));
+ NewCall->setCallingConv(Call->getCallingConv());
+ NewCall->takeName(Call);
+ FC->recordConvertedAndErase(Call, NewCall);
+ }
+ } else if (InvokeInst *Call = dyn_cast<InvokeInst>(Inst)) {
+ SmallVector<Value *, 10> Args;
+ for (unsigned I = 0; I < Call->getNumArgOperands(); ++I)
+ Args.push_back(FC->convert(Call->getArgOperand(I)));
+ InvokeInst *NewCall = InvokeInst::Create(
+ FC->convertFunctionPtr(Call->getCalledValue(), Call),
+ Call->getNormalDest(),
+ Call->getUnwindDest(),
+ Args, "", Inst);
+ CopyDebug(NewCall, Call);
+ NewCall->setAttributes(RemovePointerAttrs(Call->getContext(),
+ Call->getAttributes()));
+ NewCall->setCallingConv(Call->getCallingConv());
+ NewCall->takeName(Call);
+ FC->recordConvertedAndErase(Call, NewCall);
+ } else if (AllocaInst *Alloca = dyn_cast<AllocaInst>(Inst)) {
+ Type *ElementTy = Inst->getType()->getPointerElementType();
+ Type *ElementTy2 = ArrayType::get(Type::getInt8Ty(Inst->getContext()),
+ DL->getTypeAllocSize(ElementTy));
+ unsigned Alignment = Alloca->getAlignment();
+ if (Alignment == 0)
+ Alignment = DL->getPrefTypeAlignment(ElementTy);
+ Value *Tmp = CopyDebug(new AllocaInst(ElementTy2, Alloca->getArraySize(),
+ Alignment, "", Inst),
+ Inst);
+ Tmp->takeName(Alloca);
+ Value *Alloca2 = new PtrToIntInst(Tmp, IntPtrType,
+ Tmp->getName() + ".asint", Inst);
+ FC->recordConvertedAndErase(Alloca, Alloca2);
+ } else if (// These atomics only operate on integer pointers, not
+ // other pointers, so we don't need to recreate the
+ // instruction.
+ isa<AtomicCmpXchgInst>(Inst) ||
+ isa<AtomicRMWInst>(Inst) ||
+ // Handle these instructions as a convenience to allow
+ // the pass to be used in more situations, even though we
+ // don't expect them in PNaCl's stable ABI.
+ isa<GetElementPtrInst>(Inst) ||
+ isa<VAArgInst>(Inst) ||
+ isa<IndirectBrInst>(Inst) ||
+ isa<ExtractValueInst>(Inst) ||
+ isa<InsertValueInst>(Inst)) {
+ FC->convertInPlace(Inst);
+ }
+}
+
+// Convert ptrtoint+inttoptr to a bitcast because it's shorter and
+// because some intrinsics work on bitcasts but not on
+// ptrtoint+inttoptr, in particular:
+// * llvm.lifetime.start/end (although we strip these out)
+// * llvm.eh.typeid.for
+static void SimplifyCasts(Instruction *Inst, Type *IntPtrType) {
+ if (IntToPtrInst *Cast1 = dyn_cast<IntToPtrInst>(Inst)) {
+ if (PtrToIntInst *Cast2 = dyn_cast<PtrToIntInst>(Cast1->getOperand(0))) {
+ assert(Cast2->getType() == IntPtrType);
+ Value *V = Cast2->getPointerOperand();
+ if (V->getType() != Cast1->getType())
+ V = new BitCastInst(V, Cast1->getType(), V->getName() + ".bc", Cast1);
+ Cast1->replaceAllUsesWith(V);
+ if (Cast1->use_empty())
+ Cast1->eraseFromParent();
+ if (Cast2->use_empty())
+ Cast2->eraseFromParent();
+ }
+ }
+}
+
+static void CleanUpFunction(Function *Func, Type *IntPtrType) {
+ // Remove the ptrtoint/bitcast ConstantExprs we introduced for
+ // referencing globals.
+ FunctionPass *Pass = createExpandConstantExprPass();
+ Pass->runOnFunction(*Func);
+ delete Pass;
+
+ for (Function::iterator BB = Func->begin(), E = Func->end();
+ BB != E; ++BB) {
+ for (BasicBlock::iterator Iter = BB->begin(), E = BB->end();
+ Iter != E; ) {
+ SimplifyCasts(Iter++, IntPtrType);
+ }
+ }
+ // Cleanup: Remove ptrtoints that were introduced for allocas but not used.
+ for (Function::iterator BB = Func->begin(), E = Func->end();
+ BB != E; ++BB) {
+ for (BasicBlock::iterator Iter = BB->begin(), E = BB->end();
+ Iter != E; ) {
+ Instruction *Inst = Iter++;
+ if (isa<PtrToIntInst>(Inst) && Inst->use_empty())
+ Inst->eraseFromParent();
+ }
+ }
+}
+
+char ReplacePtrsWithInts::ID = 0;
+INITIALIZE_PASS(ReplacePtrsWithInts, "replace-ptrs-with-ints",
+ "Convert pointer values to integer values",
+ false, false)
+
+bool ReplacePtrsWithInts::runOnModule(Module &M) {
+ DataLayout DL(&M);
+ Type *IntPtrType = DL.getIntPtrType(M.getContext());
+
+ for (Module::iterator Iter = M.begin(), E = M.end(); Iter != E; ) {
+ Function *OldFunc = Iter++;
+ // Intrinsics' types must be left alone.
+ if (OldFunc->isIntrinsic())
+ continue;
+
+ FunctionConverter FC(IntPtrType);
+ FunctionType *NFTy = FC.convertFuncType(OldFunc->getFunctionType());
+
+ // In order to change the function's argument types, we have to
+ // recreate the function.
+ Function *NewFunc = Function::Create(NFTy, OldFunc->getLinkage());
+ NewFunc->copyAttributesFrom(OldFunc);
+ NewFunc->setAttributes(RemovePointerAttrs(M.getContext(),
+ NewFunc->getAttributes()));
+ M.getFunctionList().insert(OldFunc, NewFunc);
+ NewFunc->takeName(OldFunc);
+ NewFunc->getBasicBlockList().splice(NewFunc->begin(),
+ OldFunc->getBasicBlockList());
+
+ // Move the arguments across to the new function.
+ for (Function::arg_iterator Arg = OldFunc->arg_begin(),
+ E = OldFunc->arg_end(), NewArg = NewFunc->arg_begin();
+ Arg != E; ++Arg, ++NewArg) {
+ FC.recordConverted(Arg, NewArg);
+ NewArg->takeName(Arg);
+ }
+
+ // Convert the function body.
+ for (Function::iterator BB = NewFunc->begin(), E = NewFunc->end();
+ BB != E; ++BB) {
+ for (BasicBlock::iterator Iter = BB->begin(), E = BB->end();
+ Iter != E; ) {
+ ConvertInstruction(&DL, IntPtrType, &FC, Iter++);
+ }
+ }
+ FC.eraseReplacedInstructions();
+ OldFunc->replaceAllUsesWith(ConstantExpr::getBitCast(NewFunc,
+ OldFunc->getType()));
+ OldFunc->eraseFromParent();
+ }
+ // Now that all functions have their normalized types, we can remove
+ // various casts.
+ for (Module::iterator Func = M.begin(), E = M.end(); Func != E; ++Func) {
+ CleanUpFunction(Func, IntPtrType);
+ }
+ return true;
+}
+
+ModulePass *llvm::createReplacePtrsWithIntsPass() {
+ return new ReplacePtrsWithInts();
+}
diff --git a/test/Transforms/NaCl/replace-ptrs-with-ints.ll b/test/Transforms/NaCl/replace-ptrs-with-ints.ll
new file mode 100644
index 0000000000..c45ca322cd
--- /dev/null
+++ b/test/Transforms/NaCl/replace-ptrs-with-ints.ll
@@ -0,0 +1,511 @@
+; RUN: opt %s -replace-ptrs-with-ints -S | FileCheck %s
+
+target datalayout = "p:32:32:32"
+
+
+%struct = type { i32, i32 }
+
+declare %struct* @addr_taken_func(%struct*)
+
+@addr_of_func = global %struct* (%struct*)* @addr_taken_func
+; CHECK: @addr_of_func = global %struct* (%struct*)* bitcast (i32 (i32)* @addr_taken_func to %struct* (%struct*)*)
+
+@blockaddr = global i8* blockaddress(@indirectbr, %l1)
+; CHECK: @blockaddr = global i8* blockaddress(@indirectbr, %l1)
+
+
+define i8* @pointer_arg(i8* %ptr, i64 %non_ptr) {
+ ret i8* %ptr
+}
+; CHECK: define i32 @pointer_arg(i32 %ptr, i64 %non_ptr) {
+; CHECK-NEXT: ret i32 %ptr
+; CHECK-NEXT: }
+
+
+declare i8* @declared_func(i8*, i64)
+; CHECK: declare i32 @declared_func(i32, i64)
+
+
+define void @self_reference(i8* %ptr) {
+entry:
+ br label %loop
+loop:
+ %x = phi i8* [ %x, %loop ], [ %ptr, %entry ]
+ br label %loop
+}
+; CHECK: define void @self_reference(i32 %ptr) {
+; CHECK: %x = phi i32 [ %x, %loop ], [ %ptr, %entry ]
+
+define i8* @phi_multiple_entry(i1 %arg, i8* %ptr) {
+entry:
+ br i1 %arg, label %done, label %done
+done:
+ %result = phi i8* [ %ptr, %entry ], [ %ptr, %entry ]
+ ret i8* %result
+}
+; CHECK: define i32 @phi_multiple_entry(i1 %arg, i32 %ptr) {
+; CHECK: %result = phi i32 [ %ptr, %entry ], [ %ptr, %entry ]
+
+
+define i8* @select(i1 %cond, i8* %val1, i8* %val2) {
+ %r = select i1 %cond, i8* %val1, i8* %val2
+ ret i8* %r
+}
+; CHECK: define i32 @select(i1 %cond, i32 %val1, i32 %val2) {
+; CHECK-NEXT: %r = select i1 %cond, i32 %val1, i32 %val2
+
+
+define i32* @ptrtoint_same_size(i32* %ptr) {
+ %a = ptrtoint i32* %ptr to i32
+ %b = add i32 %a, 4
+ %c = inttoptr i32 %b to i32*
+ ret i32* %c
+}
+; CHECK: define i32 @ptrtoint_same_size(i32 %ptr) {
+; CHECK-NEXT: %b = add i32 %ptr, 4
+; CHECK-NEXT: ret i32 %b
+
+
+define i32* @ptrtoint_different_size(i32* %ptr) {
+ %a = ptrtoint i32* %ptr to i64
+ %b = add i64 %a, 4
+ %c = inttoptr i64 %b to i32*
+ ret i32* %c
+}
+; CHECK: define i32 @ptrtoint_different_size(i32 %ptr) {
+; CHECK-NEXT: %a = zext i32 %ptr to i64
+; CHECK-NEXT: %b = add i64 %a, 4
+; CHECK-NEXT: %c = trunc i64 %b to i32
+; CHECK-NEXT: ret i32 %c
+
+
+define i32* @pointer_bitcast(i64* %ptr) {
+ %cast = bitcast i64* %ptr to i32*
+ ret i32* %cast
+}
+; CHECK: define i32 @pointer_bitcast(i32 %ptr) {
+; CHECK-NEXT: ret i32 %ptr
+
+; Same-type non-pointer bitcasts happen to be left alone by this pass.
+define i32 @no_op_bitcast(i32 %val) {
+ %val2 = bitcast i32 %val to i32
+ ret i32 %val2
+}
+; CHECK: define i32 @no_op_bitcast(i32 %val) {
+; CHECK-NEXT: %val2 = bitcast i32 %val to i32
+
+define i64 @kept_bitcast(double %d) {
+ %i = bitcast double %d to i64
+ ret i64 %i
+}
+; CHECK: define i64 @kept_bitcast(double %d) {
+; CHECK-NEXT: %i = bitcast double %d to i64
+
+
+define i32 @constant_pointer_null() {
+ %val = ptrtoint i32* null to i32
+ ret i32 %val
+}
+; CHECK: define i32 @constant_pointer_null() {
+; CHECK-NEXT: ret i32 0
+
+define i32 @constant_pointer_undef() {
+ %val = ptrtoint i32* undef to i32
+ ret i32 %val
+}
+; CHECK: define i32 @constant_pointer_undef() {
+; CHECK-NEXT: ret i32 undef
+
+define i16* @constant_pointer_null_load() {
+ %val = load i16** null
+ ret i16* %val
+}
+; CHECK: define i32 @constant_pointer_null_load() {
+; CHECK-NEXT: %.asptr = inttoptr i32 0 to i32*
+; CHECK-NEXT: %val = load i32* %.asptr
+
+
+define i8 @load(i8* %ptr) {
+ %x = load i8* %ptr
+ ret i8 %x
+}
+; CHECK: define i8 @load(i32 %ptr) {
+; CHECK-NEXT: %ptr.asptr = inttoptr i32 %ptr to i8*
+; CHECK-NEXT: %x = load i8* %ptr.asptr
+
+define void @store(i8* %ptr, i8 %val) {
+ store i8 %val, i8* %ptr
+ ret void
+}
+; CHECK: define void @store(i32 %ptr, i8 %val) {
+; CHECK-NEXT: %ptr.asptr = inttoptr i32 %ptr to i8*
+; CHECK-NEXT: store i8 %val, i8* %ptr.asptr
+
+
+define i8* @load_ptr(i8** %ptr) {
+ %x = load i8** %ptr
+ ret i8* %x
+}
+; CHECK: define i32 @load_ptr(i32 %ptr) {
+; CHECK-NEXT: %ptr.asptr = inttoptr i32 %ptr to i32*
+; CHECK-NEXT: %x = load i32* %ptr.asptr
+
+define void @store_ptr(i8** %ptr, i8* %val) {
+ store i8* %val, i8** %ptr
+ ret void
+}
+; CHECK: define void @store_ptr(i32 %ptr, i32 %val) {
+; CHECK-NEXT: %ptr.asptr = inttoptr i32 %ptr to i32*
+; CHECK-NEXT: store i32 %val, i32* %ptr.asptr
+
+
+define i8 @load_attrs(i8* %ptr) {
+ %x = load atomic volatile i8* %ptr seq_cst, align 128
+ ret i8 %x
+}
+; CHECK: define i8 @load_attrs(i32 %ptr) {
+; CHECK-NEXT: %ptr.asptr = inttoptr i32 %ptr to i8*
+; CHECK-NEXT: %x = load atomic volatile i8* %ptr.asptr seq_cst, align 128
+
+define void @store_attrs(i8* %ptr, i8 %val) {
+ store atomic volatile i8 %val, i8* %ptr singlethread release, align 256
+ ret void
+}
+; CHECK: define void @store_attrs(i32 %ptr, i8 %val) {
+; CHECK-NEXT: %ptr.asptr = inttoptr i32 %ptr to i8*
+; CHECK-NEXT: store atomic volatile i8 %val, i8* %ptr.asptr singlethread release, align 256
+
+
+define i32 @cmpxchg(i32* %ptr, i32 %a, i32 %b) {
+ %r = cmpxchg i32* %ptr, i32 %a, i32 %b seq_cst
+ ret i32 %r
+}
+; CHECK: define i32 @cmpxchg(i32 %ptr, i32 %a, i32 %b) {
+; CHECK-NEXT: %ptr.asptr = inttoptr i32 %ptr to i32*
+; CHECK-NEXT: %r = cmpxchg i32* %ptr.asptr, i32 %a, i32 %b seq_cst
+
+define i32 @atomicrmw(i32* %ptr, i32 %x) {
+ %r = atomicrmw add i32* %ptr, i32 %x seq_cst
+ ret i32 %r
+}
+; CHECK: define i32 @atomicrmw(i32 %ptr, i32 %x) {
+; CHECK-NEXT: %ptr.asptr = inttoptr i32 %ptr to i32*
+; CHECK-NEXT: %r = atomicrmw add i32* %ptr.asptr, i32 %x seq_cst
+
+
+define i8* @indirect_call(i8* (i8*)* %func, i8* %arg) {
+ %result = call i8* %func(i8* %arg)
+ ret i8* %result
+}
+; CHECK: define i32 @indirect_call(i32 %func, i32 %arg) {
+; CHECK-NEXT: %func.asfuncptr = inttoptr i32 %func to i32 (i32)*
+; CHECK-NEXT: %result = call i32 %func.asfuncptr(i32 %arg)
+; CHECK-NEXT: ret i32 %result
+
+
+; Test forwards reference
+define i8* @direct_call1(i8* %arg) {
+ %result = call i8* @direct_call2(i8* %arg)
+ ret i8* %result
+}
+; CHECK: define i32 @direct_call1(i32 %arg) {
+; CHECK-NEXT: %result = call i32 @direct_call2(i32 %arg)
+; CHECK-NEXT: ret i32 %result
+
+; Test backwards reference
+define i8* @direct_call2(i8* %arg) {
+ %result = call i8* @direct_call1(i8* %arg)
+ ret i8* %result
+}
+; CHECK: define i32 @direct_call2(i32 %arg) {
+; CHECK-NEXT: %result = call i32 @direct_call1(i32 %arg)
+; CHECK-NEXT: ret i32 %result
+
+
+@var = global i32 0
+
+define i32* @get_addr_of_global() {
+ ret i32* @var
+}
+; CHECK: define i32 @get_addr_of_global() {
+; CHECK-NEXT: %expanded = ptrtoint i32* @var to i32
+; CHECK-NEXT: ret i32 %expanded
+
+define %struct* (%struct*)* @get_addr_of_func() {
+ ret %struct* (%struct*)* @addr_taken_func
+}
+; CHECK: define i32 @get_addr_of_func() {
+; CHECK-NEXT: %expanded = ptrtoint i32 (i32)* @addr_taken_func to i32
+; CEHCK-NEXT: ret i32 %expanded
+
+
+define i32 @load_global() {
+ %val = load i32* @var
+ ret i32 %val
+}
+; CHECK: define i32 @load_global() {
+; CHECK-NEXT: %val = load i32* @var
+; CHECK-NEXT: ret i32 %val
+
+define i16 @load_global_bitcast() {
+ %ptr = bitcast i32* @var to i16*
+ %val = load i16* %ptr
+ ret i16 %val
+}
+; CHECK: define i16 @load_global_bitcast() {
+; CHECK-NEXT: %var.bc = bitcast i32* @var to i16*
+; CHECK-NEXT: %val = load i16* %var.bc
+; CHECK-NEXT: ret i16 %val
+
+
+declare void @receive_alloca(%struct* %ptr)
+
+define void @alloca_fixed() {
+ %buf = alloca %struct, align 128
+ call void @receive_alloca(%struct* %buf)
+ ret void
+}
+; CHECK: define void @alloca_fixed() {
+; CHECK-NEXT: %buf = alloca [8 x i8], align 128
+; CHECK-NEXT: %buf.asint = ptrtoint [8 x i8]* %buf to i32
+; CHECK-NEXT: call void @receive_alloca(i32 %buf.asint)
+
+define void @alloca_variable(i32 %size) {
+ %buf = alloca %struct, i32 %size
+ call void @recei