Changes from 3.7 merge to files not in upstream

lib/Transforms/MinSFI/SandboxIndirectCalls.cpp

 //===- SandboxIndirectCalls.cpp - Apply CFI to indirect function calls ----===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This is a pass which applies basic control-flow integrity enforcement to
@@ skipping 49 matching lines @@
 };
 }  // namespace
 
 static inline size_t RoundToPowerOf2(size_t n) {
   if (isPowerOf2_64(n))
     return n;
   else
     return NextPowerOf2(n);
 }
 
-static inline bool IsPtrToIntUse(const Function::user_iterator &FuncUser) {
-  if (isa<PtrToIntInst>(*FuncUser))
+static inline bool IsPtrToIntUse(const Use &FuncUse) {
+  if (isa<PtrToIntInst>(FuncUse.getUser()))
     return true;
-  else if (ConstantExpr *Expr = dyn_cast<ConstantExpr>(*FuncUser))
+  else if (auto *Expr = dyn_cast<ConstantExpr>(FuncUse.getUser()))
     return Expr->getOpcode() == Instruction::PtrToInt;
   else
     return false;
 }
 
 // Function use is a direct call if the user is a call instruction and
 // the function is its last operand.
-static inline bool IsDirectCallUse(const Function::user_iterator &FuncUser) {
-  if (CallInst *Call = dyn_cast<CallInst>(*FuncUser))
-    return FuncUser.getOperandNo() == Call->getNumArgOperands();
-  else
-    return false;
+static inline bool IsDirectCallUse(const Use &FuncUse) {
+  if (auto *Call = dyn_cast<CallInst>(FuncUse.getUser())) {
+    return FuncUse.getOperandNo() == Call->getNumOperands() - 1;
+  }
+  return false;
 }
 
 bool SandboxIndirectCalls::runOnModule(Module &M) {
   typedef SmallVector<Constant*, 16> FunctionVector;
   DataLayout DL(&M);
   Type *I32 = Type::getInt32Ty(M.getContext());
   Type *IntPtrType = DL.getIntPtrType(M.getContext());
 
   // First, we find all address-taken functions and assign each an index.
   // Pointers in code are then immediately replaced with these indices, even
   // though the tables have not been created yet.
   FunctionVector AddrTakenFuncs;
   for (Module::iterator Func = M.begin(), E = M.end(); Func != E; ++Func) {
     bool HasIndirectUse = false;
     Constant *Index = ConstantInt::get(IntPtrType, AddrTakenFuncs.size() + 1);
-    for (Function::user_iterator User = Func->user_begin(),
-                                 E = Func->user_end();
-         User != E; ++User) {
-      if (IsPtrToIntUse(User)) {
+    for (auto &Use : Func->uses()) {
+      if (IsPtrToIntUse(Use)) {
         HasIndirectUse = true;
-        (*User)->replaceAllUsesWith(Index);
-        if (Instruction *UserInst = dyn_cast<Instruction>(*User))
+        Use.getUser()->replaceAllUsesWith(Index);
+        if (auto *UserInst = dyn_cast<Instruction>(Use.getUser()))
           UserInst->eraseFromParent();
-      } else if (!IsDirectCallUse(User)) {
+      } else if (!IsDirectCallUse(Use)) {
         report_fatal_error("SandboxIndirectCalls: Invalid reference to "
                            "function @" + Func->getName());
       }
     }
 
     if (HasIndirectUse)
       AddrTakenFuncs.push_back(Func);
   }
 
   // Return if no address-taken functions have been found.
@@ skipping 49 matching lines @@
           if (IntToPtrInst *Cast = dyn_cast<IntToPtrInst>(Callee)) {
             Value *FuncIndex = Cast->getOperand(0);
             PointerType *FuncType = cast<PointerType>(Cast->getType());
             Constant *GlobalVar = TableGlobals[FuncType];
 
             Value *FuncPtr;
             if (GlobalVar) {
               Instruction *MaskedIndex =
                   BinaryOperator::CreateAnd(FuncIndex, IndexMask, "", Call);
               Value *Indexes[] = { ConstantInt::get(I32, 0), MaskedIndex };
-              Instruction *TableElemPtr =
-                  GetElementPtrInst::Create(GlobalVar, Indexes, "", Call);
+              Instruction *TableElemPtr = GetElementPtrInst::Create(
+                  cast<PointerType>(GlobalVar->getType())->getElementType(),
+                  GlobalVar, Indexes, "", Call);
               FuncPtr = CopyDebug(new LoadInst(TableElemPtr, "", Call), Cast);
             } else {
               // There is no function table for this signature, i.e. the module
               // does not contain a function which could be called at this site.
               // We replace the pointer with a null and put a trap in front of
               // the call because it should never be called.
               CallInst::Create(Intrinsic::getDeclaration(&M, Intrinsic::trap),
                                "", Call);
               FuncPtr = ConstantPointerNull::get(FuncType);
             }
@@ skipping 10 matching lines @@
   return true;
 }
 
 char SandboxIndirectCalls::ID = 0;
 INITIALIZE_PASS(SandboxIndirectCalls, "minsfi-sandbox-indirect-calls",
                 "Add CFI to indirect calls", false, false)
 
 ModulePass *llvm::createSandboxIndirectCallsPass() {
   return new SandboxIndirectCalls();
 }