Changes from 3.7 merge to files not in upstream

lib/Transforms/NaCl/ReplacePtrsWithInts.cpp

 //===- 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
@@ skipping 265 matching lines @@
        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, /* BypassPlaceholder= */ true);
-    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) {
@@ skipping 12 matching lines @@
           break;
         // Strip these attributes because they apply only to pointers. This pass
         // rewrites pointer arguments, thus these parameter attributes are
         // meaningless. Also, they are rejected by the PNaCl module verifier.
         case Attribute::NoCapture:
         case Attribute::NoAlias:
         case Attribute::ReadNone:
         case Attribute::ReadOnly:
         case Attribute::NonNull:
         case Attribute::Dereferenceable:
+        case Attribute::DereferenceableOrNull:
           break;
         default:
           AB.addAttribute(*Attr);
       }
     }
     AttrList.push_back(AttributeSet::get(Context, Index, AB));
   }
   return AttributeSet::get(Context, AttrList);
 }
 
@@ skipping 238 matching lines @@
     }
 
     // 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++);
       }
     }
-    // Now that all the replacement instructions have been created, we

[jvoung (off chromium), 2015/05/26 20:39:45]

this is automatic now?

[Derek Schuff, 2015/05/26 22:01:32]

RAUW seems to work on MetadataAsValue. We could maybe even get debug.value to
work now, but I'm not sure it's worth the effort.

-    // can update the debug intrinsic calls.
-    for (Function::iterator BB = NewFunc->begin(), E = NewFunc->end();
-         BB != E; ++BB) {
-      for (BasicBlock::iterator Inst = BB->begin(), E = BB->end();
-           Inst != E; ++Inst) {
-        if (IntrinsicInst *Call = dyn_cast<IntrinsicInst>(Inst)) {
-          if (Call->getIntrinsicID() == Intrinsic::dbg_declare) {
-            ConvertMetadataOperand(&FC, Call, 0);
-          }
-        }
-      }
-    }
     FC.eraseReplacedInstructions();
 
     // Patch the pointer to LLVM function in debug info descriptor.
     auto DI = FunctionDIs.find(OldFunc);
     if (DI != FunctionDIs.end())
-      DI->second.replaceFunction(NewFunc);
+      DI->second->replaceFunction(NewFunc);
 
     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);
     // Delete the now-unused bitcast ConstantExprs that we created so
     // that they don't interfere with StripDeadPrototypes.
     Func->removeDeadConstantUsers();
   }
   return true;
 }
 
 ModulePass *llvm::createReplacePtrsWithIntsPass() {
   return new ReplacePtrsWithInts();
 }