Changes from 3.7 merge to files not in upstream

lib/Analysis/NaCl/PNaClABIVerifyFunctions.cpp

 //===- PNaClABIVerifyFunctions.cpp - Verify PNaCl ABI rules ---------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Verify function-level PNaCl ABI requirements.
 //
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Analysis/NaCl/PNaClABIVerifyFunctions.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Analysis/NaCl.h"
 #include "llvm/Analysis/NaCl/PNaClABITypeChecker.h"
+#include "llvm/Analysis/NaCl/PNaClAllowedIntrinsics.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
@@ skipping 402 matching lines @@
         return "inline assembly";
       if (!Call->getAttributes().isEmpty())
         return "bad call attributes";
       if (!PNaClABIProps::isValidCallingConv(Call->getCallingConv()))
         return "bad calling convention";
 
       // Intrinsic calls can have multiple pointer arguments and
       // metadata arguments, so handle them specially.
       // TODO(kschimpf) How can we lift this to pnacl-bcdis.
       if (const IntrinsicInst *Call = dyn_cast<IntrinsicInst>(Inst)) {
+        if (PNaClAllowedIntrinsics::isAllowedDebugInfoIntrinsic(
+                Call->getIntrinsicID())) {
+          // If debug metadata is allowed, always allow calling debug intrinsics
+          // and assume they are correct.
+          return nullptr;
+        }
         for (unsigned ArgNum = 0, E = Call->getNumArgOperands();
              ArgNum < E; ++ArgNum) {
           const Value *Arg = Call->getArgOperand(ArgNum);
           if (!(isValidScalarOperand(Arg) ||
                 isValidVectorOperand(Arg) ||
-                isNormalizedPtr(Arg) ||
-                isa<MDNode>(Arg)))
+                isNormalizedPtr(Arg)))
             return "bad intrinsic operand";
         }
 
         // Disallow alignments other than 1 on memcpy() etc., for the
         // same reason that we disallow them on integer loads and
         // stores.
         if (const MemIntrinsic *MemOp = dyn_cast<MemIntrinsic>(Call)) {
           // Avoid the getAlignment() method here because it aborts if
           // the alignment argument is not a Constant.
           Value *AlignArg = MemOp->getArgOperand(3);
@@ skipping 96 matching lines @@
           dyn_cast<PossiblyExactOperator>(Inst)) {
     if (Op->isExact())
       return "has \"exact\" attribute";
   }
 
   // Allow the instruction.
   return NULL;
 }
 
 bool PNaClABIVerifyFunctions::runOnFunction(Function &F) {
-  const DataLayout *DL = &getAnalysis<DataLayoutPass>().getDataLayout();
+  const DataLayout *DL = &F.getParent()->getDataLayout();
   SmallVector<StringRef, 8> MDNames;
   F.getContext().getMDKindNames(MDNames);
 
   for (Function::const_iterator FI = F.begin(), FE = F.end();
            FI != FE; ++FI) {
     for (BasicBlock::const_iterator BBI = FI->begin(), BBE = FI->end();
              BBI != BBE; ++BBI) {
       const Instruction *Inst = BBI;
       // Check the instruction opcode first.  This simplifies testing,
       // because some instruction opcodes must be rejected out of hand
@@ skipping 45 matching lines @@
 }
 
 char PNaClABIVerifyFunctions::ID = 0;
 INITIALIZE_PASS(PNaClABIVerifyFunctions, "verify-pnaclabi-functions",
                 "Verify functions for PNaCl", false, true)
 
 FunctionPass *llvm::createPNaClABIVerifyFunctionsPass(
     PNaClABIErrorReporter *Reporter) {
   return new PNaClABIVerifyFunctions(Reporter);
 }