[IR] Move optional data in llvm::Function into a hungoff uselist

[vsk]

Summary

This patch makes personality functions, prefix data, and prologue data hungoff operands of Function. It lets us remove a bit of code and generally cleans things up in llvm::Function. The consensus seems to be that this has a negligible impact on performance.

More discussion (and performance numbers) are available here: http://lists.llvm.org/pipermail/llvm-dev/2015-October/091169.html

[sanjoy]

include/llvm/IR/Function.h

67 ↗

(On Diff #37632)

Was the earlier comment incorrect? (i.e. CallingConvention should have been 3-15 earlier)?

If so, you might want to correct that mistake separately and check that in, and rebase this patch over that. That'll make the diff clearer.

Also, why did you choose bit 15? Doesn't it make sense to group this together with the rest of the Has* enums, before CallingConvention? (What you have here is fine btw, I'm just curious).

158 ↗

(On Diff #37632)

I'm not sure this is correct -- are you | ing over the new calling convention over what was there previously? Won't setting the calling convention to 4 and then to 2 end up setting it to 6?

488 ↗

(On Diff #37632)

Add a doxygen comment.

lib/IR/Function.cpp

973 ↗

(On Diff #37632)

Minor: I'd call ConstantPointerNull::get only if C is nullptr.

Also, do you really need to support the setHungoffOperand(nullptr) case? I think creating and passing in a i8* null or whatever should be up to the caller.

[vsk]

Thanks for the review.

• Addressed correctness issue Sanjoy pointed out by rebasing to D13826.
• Added comments where requested.

[vsk]

Addressed some inline comments.

include/llvm/IR/Function.h

67 ↗

(On Diff #37632)

Yes, CallingConvention should have been 3-15 earlier. I will correct it in D13826.

I chose bit 15 because of an incorrect assumption. I thought the SubclassData field is serialized, and that we needed to be sensitive about re-ordering the bits in it. I'll switch over to bit 4 in D13826.

lib/IR/Function.cpp

973 ↗

(On Diff #37779)

Fixed.

Yes, we have to remap setHungoffOperand(nullptr) to a real Constant. llvm assumes that operands are non-null all over the place, in ways that can't be guarded against by checking hasPersonality, hasPrefixData etc. The previous API got around this problem by deleting its operand when nullptr is set.

[vsk]

• Fix brain-o where I didn't use bit 3 for HasPersonalityFn.

[sanjoy]

lib/IR/Function.cpp

973 ↗

(On Diff #37781)

By not supporting setHungoffOperand(nullptr), I meant putting an assert(C && "nullptr not allowed!") here.

[vsk]

• Disallow nullptr argument to setHungoffOperand().

[vsk]

• Rebased to master for the required CallingConv changes.
• First real candidate diff is ready.

[vsk]

Gentle ping

[sanjoy]

I'm not familiar with all of the pieces you're touching here, but apart from the minor nit mentioned inline I don't have much to add.

lib/IR/Function.cpp

330 ↗

(On Diff #38599)

Can you use dropAllReferences here?

[vsk]

• Updated diff according to Sanjoy's suggestion.

[vsk]

This isn't urgent but it's been a while. Ping?

llvm/trunk/include/llvm/IR/Function.h

private:
   FunctionType *Ty;
 
   /*
    * Value::SubclassData
    *
    * bit 0      : HasLazyArguments
    * bit 1      : HasPrefixData
    * bit 2      : HasPrologueData
-   * bit 3      : [reserved]
+   * bit 3      : HasPersonalityFn
    * bits 4-13  : CallingConvention
    * bits 14-15 : [reserved]
    */
 
   /// Bits from GlobalObject::GlobalObjectSubclassData.
   enum {
     /// Whether this function is materializable.
     IsMaterializableBit = 1 << 0,
private:
   /// the module.
   ///
   Function(FunctionType *Ty, LinkageTypes Linkage,
            const Twine &N = "", Module *M = nullptr);
 
 public:
   static Function *Create(FunctionType *Ty, LinkageTypes Linkage,
                           const Twine &N = "", Module *M = nullptr) {
-    return new(1) Function(Ty, Linkage, N, M);
+    return new Function(Ty, Linkage, N, M);
   }
 
   ~Function() override;
 
   /// \brief Provide fast operand accessors
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 
-  /// \brief Get the personality function associated with this function.
-  bool hasPersonalityFn() const { return getNumOperands() != 0; }
-  Constant *getPersonalityFn() const {
-    assert(hasPersonalityFn());
-    return cast<Constant>(Op<0>());
-  }
-  void setPersonalityFn(Constant *C);
-
   Type *getReturnType() const;           // Return the type of the ret val
   FunctionType *getFunctionType() const; // Return the FunctionType for me
 
   /// getContext - Return a reference to the LLVMContext associated with this
   /// function.
   LLVMContext &getContext() const;
 
   /// isVarArg - Return true if this function takes a variable number of
iterator_range<const_arg_iterator> args() const {
     return make_range(arg_begin(), arg_end());
   }
 
 /// @}
 
   size_t arg_size() const;
   bool arg_empty() const;
 
+  /// \brief Check whether this function has a personality function.
+  bool hasPersonalityFn() const {
+    return getSubclassDataFromValue() & (1<<3);
+  }
+
+  /// \brief Get the personality function associated with this function.
+  Constant *getPersonalityFn() const;
+  void setPersonalityFn(Constant *Fn);
+
+  /// \brief Check whether this function has prefix data.
   bool hasPrefixData() const {
     return getSubclassDataFromValue() & (1<<1);
   }
 
+  /// \brief Get the prefix data associated with this function.
   Constant *getPrefixData() const;
   void setPrefixData(Constant *PrefixData);
 
+  /// \brief Check whether this function has prologue data.
   bool hasPrologueData() const {
     return getSubclassDataFromValue() & (1<<2);
   }
 
+  /// \brief Get the prologue data associated with this function.
   Constant *getPrologueData() const;
   void setPrologueData(Constant *PrologueData);
 
   /// viewCFG - This function is meant for use from the debugger.  You can just
   /// say 'call F->viewCFG()' and a ghostview window should pop up from the
   /// program, displaying the CFG of the current function with the code for each
   /// basic block inside.  This depends on there being a 'dot' and 'gv' program
   /// in your path.
/// @}
 
   /// \brief Get the attached subprogram.
   ///
   /// Calls \a getMetadata() with \a LLVMContext::MD_dbg and casts the result
   /// to \a DISubprogram.
   DISubprogram *getSubprogram() const;
 
 private:
+  void allocHungoffUselist();
+  template<int Idx> void setHungoffOperand(Constant *C);
+
   // Shadow Value::setValueSubclassData with a private forwarding method so that
   // subclasses cannot accidentally use it.
   void setValueSubclassData(unsigned short D) {
     Value::setValueSubclassData(D);
   }
+  void setValueSubclassDataBit(unsigned Bit, bool On);
 
   bool hasMetadataHashEntry() const {
     return getGlobalObjectSubClassData() & HasMetadataHashEntryBit;
   }
   void setHasMetadataHashEntry(bool HasEntry) {
     setGlobalObjectBit(HasMetadataHashEntryBit, HasEntry);
   }
 
   void clearMetadata();
 };
 
 template <>
-struct OperandTraits<Function> : public OptionalOperandTraits<Function> {};
+struct OperandTraits<Function> : public HungoffOperandTraits<3> {};
 
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(Function, Value)
 
 } // End llvm namespace
 
 #endif

llvm/trunk/include/llvm/IR/User.h

public:
   /// FIXME: As that the number of operands is used to find the start of
   /// the allocated memory in operator delete, we need to always think we have
   /// 1 operand before delete.
   void setGlobalVariableNumOperands(unsigned NumOps) {
     assert(NumOps <= 1 && "GlobalVariable can only have 0 or 1 operands");
     NumUserOperands = NumOps;
   }
 
-  /// Set the number of operands on a Function.
-  ///
-  /// Function always allocates space for a single operands, but
-  /// doesn't always use it.
-  ///
-  /// FIXME: As that the number of operands is used to find the start of
-  /// the allocated memory in operator delete, we need to always think we have
-  /// 1 operand before delete.
-  void setFunctionNumOperands(unsigned NumOps) {
-    assert(NumOps <= 1 && "Function can only have 0 or 1 operands");
-    NumUserOperands = NumOps;
-  }
-
   /// \brief Subclasses with hung off uses need to manage the operand count
   /// themselves.  In these instances, the operand count isn't used to find the
   /// OperandList, so there's no issue in having the operand count change.
   void setNumHungOffUseOperands(unsigned NumOps) {
     assert(HasHungOffUses && "Must have hung off uses to use this method");
     assert(NumOps < (1u << NumUserOperandsBits) && "Too many operands");
     NumUserOperands = NumOps;
   }

llvm/trunk/lib/Bitcode/Writer/ValueEnumerator.cpp

static OrderMap orderModule(const Module &M) {
   for (const GlobalVariable &G : M.globals())
     if (G.hasInitializer())
       if (!isa<GlobalValue>(G.getInitializer()))
         orderValue(G.getInitializer(), OM);
   for (const GlobalAlias &A : M.aliases())
     if (!isa<GlobalValue>(A.getAliasee()))
       orderValue(A.getAliasee(), OM);
   for (const Function &F : M) {
-    if (F.hasPrefixData())
-      if (!isa<GlobalValue>(F.getPrefixData()))
-        orderValue(F.getPrefixData(), OM);
-    if (F.hasPrologueData())
-      if (!isa<GlobalValue>(F.getPrologueData()))
-        orderValue(F.getPrologueData(), OM);
-    if (F.hasPersonalityFn())
-      if (!isa<GlobalValue>(F.getPersonalityFn()))
-        orderValue(F.getPersonalityFn(), OM);
+    for (const Use &U : F.operands())
+      if (!isa<GlobalValue>(U.get()))
+        orderValue(U.get(), OM);
   }
   OM.LastGlobalConstantID = OM.size();
 
   // Initializers of GlobalValues are processed in
   // BitcodeReader::ResolveGlobalAndAliasInits().  Match the order there rather
   // than ValueEnumerator, and match the code in predictValueUseListOrderImpl()
   // by giving IDs in reverse order.
   //
static UseListOrderStack predictUseListOrder(const Module &M) {
   for (const GlobalAlias &A : M.aliases())
     predictValueUseListOrder(&A, nullptr, OM, Stack);
   for (const GlobalVariable &G : M.globals())
     if (G.hasInitializer())
       predictValueUseListOrder(G.getInitializer(), nullptr, OM, Stack);
   for (const GlobalAlias &A : M.aliases())
     predictValueUseListOrder(A.getAliasee(), nullptr, OM, Stack);
   for (const Function &F : M) {
-    if (F.hasPrefixData())
-      predictValueUseListOrder(F.getPrefixData(), nullptr, OM, Stack);
-    if (F.hasPrologueData())
-      predictValueUseListOrder(F.getPrologueData(), nullptr, OM, Stack);
-    if (F.hasPersonalityFn())
-      predictValueUseListOrder(F.getPersonalityFn(), nullptr, OM, Stack);
+    for (const Use &U : F.operands())
+      predictValueUseListOrder(U.get(), nullptr, OM, Stack);
   }
 
   return Stack;
 }
 
 static bool isIntOrIntVectorValue(const std::pair<const Value*, unsigned> &V) {
   return V.first->getType()->isIntOrIntVectorTy();
 }
ValueEnumerator::ValueEnumerator(const Module &M,
   for (const GlobalVariable &GV : M.globals())
     if (GV.hasInitializer())
       EnumerateValue(GV.getInitializer());
 
   // Enumerate the aliasees.
   for (const GlobalAlias &GA : M.aliases())
     EnumerateValue(GA.getAliasee());
 
-  // Enumerate the prefix data constants.
+  // Enumerate any optional Function data.
   for (const Function &F : M)
-    if (F.hasPrefixData())
-      EnumerateValue(F.getPrefixData());
-
-  // Enumerate the prologue data constants.
-  for (const Function &F : M)
-    if (F.hasPrologueData())
-      EnumerateValue(F.getPrologueData());
-
-  // Enumerate the personality functions.
-  for (Module::const_iterator I = M.begin(), E = M.end(); I != E; ++I)
-    if (I->hasPersonalityFn())
-      EnumerateValue(I->getPersonalityFn());
+    for (const Use &U : F.operands())
+      EnumerateValue(U.get());
 
   // Enumerate the metadata type.
   //
   // TODO: Move this to ValueEnumerator::EnumerateOperandType() once bitcode
   // only encodes the metadata type when it's used as a value.
   EnumerateType(Type::getMetadataTy(M.getContext()));
 
   // Insert constants and metadata that are named at module level into the slot

llvm/trunk/lib/IR/AsmWriter.cpp

for (const GlobalVariable &G : M->globals()) {
     orderValue(&G, OM);
   }
   for (const GlobalAlias &A : M->aliases()) {
     if (!isa<GlobalValue>(A.getAliasee()))
       orderValue(A.getAliasee(), OM);
     orderValue(&A, OM);
   }
   for (const Function &F : *M) {
-    if (F.hasPrefixData())
-      if (!isa<GlobalValue>(F.getPrefixData()))
-        orderValue(F.getPrefixData(), OM);
-
-    if (F.hasPrologueData())
-      if (!isa<GlobalValue>(F.getPrologueData()))
-        orderValue(F.getPrologueData(), OM);
-
-    if (F.hasPersonalityFn())
-      if (!isa<GlobalValue>(F.getPersonalityFn()))
-        orderValue(F.getPersonalityFn(), OM);
+    for (const Use &U : F.operands())
+      if (!isa<GlobalValue>(U.get()))
+        orderValue(U.get(), OM);
 
     orderValue(&F, OM);
 
     if (F.isDeclaration())
       continue;
 
     for (const Argument &A : F.args())
       orderValue(&A, OM);
static UseListOrderStack predictUseListOrder(const Module *M) {
   for (const GlobalAlias &A : M->aliases())
     predictValueUseListOrder(&A, nullptr, OM, Stack);
   for (const GlobalVariable &G : M->globals())
     if (G.hasInitializer())
       predictValueUseListOrder(G.getInitializer(), nullptr, OM, Stack);
   for (const GlobalAlias &A : M->aliases())
     predictValueUseListOrder(A.getAliasee(), nullptr, OM, Stack);
   for (const Function &F : *M)
-    if (F.hasPrefixData())
-      predictValueUseListOrder(F.getPrefixData(), nullptr, OM, Stack);
+    for (const Use &U : F.operands())
+      predictValueUseListOrder(U.get(), nullptr, OM, Stack);
 
   return Stack;
 }
 
 static const Module *getModuleFromVal(const Value *V) {
   if (const Argument *MA = dyn_cast<Argument>(V))
     return MA->getParent() ? MA->getParent()->getParent() : nullptr;
 

llvm/trunk/lib/IR/Function.cpp

Function::~Function() {
   dropAllReferences();    // After this it is safe to delete instructions.
 
   // Delete all of the method arguments and unlink from symbol table...
   ArgumentList.clear();
   delete SymTab;
 
   // Remove the function from the on-the-side GC table.
   clearGC();
-
-  // FIXME: needed by operator delete
-  setFunctionNumOperands(1);
 }
 
 void Function::BuildLazyArguments() const {
   // Create the arguments vector, all arguments start out unnamed.
   FunctionType *FT = getFunctionType();
   for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
     assert(!FT->getParamType(i)->isVoidTy() &&
            "Cannot have void typed arguments!");
void Function::dropAllReferences() {
   for (iterator I = begin(), E = end(); I != E; ++I)
     I->dropAllReferences();
 
   // Delete all basic blocks. They are now unused, except possibly by
   // blockaddresses, but BasicBlock's destructor takes care of those.
   while (!BasicBlocks.empty())
     BasicBlocks.begin()->eraseFromParent();
 
-  // Prefix and prologue data are stored in a side table.
-  setPrefixData(nullptr);
-  setPrologueData(nullptr);
+  // Drop uses of any optional data (real or placeholder).
+  if (getNumOperands()) {
+    User::dropAllReferences();
+    setNumHungOffUseOperands(0);
+  }
 
   // Metadata is stored in a side-table.
   clearMetadata();
-
-  setPersonalityFn(nullptr);
 }
 
 void Function::addAttribute(unsigned i, Attribute::AttrKind attr) {
   AttributeSet PAL = getAttributes();
   PAL = PAL.addAttribute(getContext(), i, attr);
   setAttributes(PAL);
 }
 
if (!SrcF)
     return;
 
   setCallingConv(SrcF->getCallingConv());
   setAttributes(SrcF->getAttributes());
   if (SrcF->hasGC())
     setGC(SrcF->getGC());
   else
     clearGC();
+  if (SrcF->hasPersonalityFn())
+    setPersonalityFn(SrcF->getPersonalityFn());
   if (SrcF->hasPrefixData())
     setPrefixData(SrcF->getPrefixData());
-  else
-    setPrefixData(nullptr);
   if (SrcF->hasPrologueData())
     setPrologueData(SrcF->getPrologueData());
-  else
-    setPrologueData(nullptr);
-  if (SrcF->hasPersonalityFn())
-    setPersonalityFn(SrcF->getPersonalityFn());
-  else
-    setPersonalityFn(nullptr);
 }
 
 /// \brief This does the actual lookup of an intrinsic ID which
 /// matches the given function name.
 static Intrinsic::ID lookupIntrinsicID(const ValueName *ValName) {
   unsigned Len = ValName->getKeyLength();
   const char *Name = ValName->getKeyData();
 
for (const_inst_iterator
     ImmutableCallSite CS(&*I);
     if (CS && CS.hasFnAttr(Attribute::ReturnsTwice))
       return true;
   }
 
   return false;
 }
 
-static Constant *
-getFunctionData(const Function *F,
-                const LLVMContextImpl::FunctionDataMapTy &Map) {
-  const auto &Entry = Map.find(F);
-  assert(Entry != Map.end());
-  return cast<Constant>(Entry->second->getReturnValue());
-}
-
-/// setFunctionData - Set "Map[F] = Data". Return an updated SubclassData value
-/// in which Bit is low iff Data is null.
-static unsigned setFunctionData(Function *F,
-                                LLVMContextImpl::FunctionDataMapTy &Map,
-                                Constant *Data, unsigned SCData, unsigned Bit) {
-  ReturnInst *&Holder = Map[F];
-  if (Data) {
-    if (Holder)
-      Holder->setOperand(0, Data);
-    else
-      Holder = ReturnInst::Create(F->getContext(), Data);
-    return SCData | (1 << Bit);
-  } else {
-    delete Holder;
-    Map.erase(F);
-    return SCData & ~(1 << Bit);
-  }
+Constant *Function::getPersonalityFn() const {
+  assert(hasPersonalityFn() && getNumOperands());
+  return cast<Constant>(Op<0>());
+
+void Function::setPersonalityFn(Constant *Fn) {
+  if (Fn)
+    setHungoffOperand<0>(Fn);
+  setValueSubclassDataBit(3, Fn != nullptr);
 }
 
 Constant *Function::getPrefixData() const {
-  assert(hasPrefixData());
-  return getFunctionData(this, getContext().pImpl->PrefixDataMap);
+  assert(hasPrefixData() && getNumOperands());
+  return cast<Constant>(Op<1>());
 }
 
 void Function::setPrefixData(Constant *PrefixData) {
-  if (!PrefixData && !hasPrefixData())
-    return;
-
-  unsigned SCData = getSubclassDataFromValue();
-  SCData = setFunctionData(this, getContext().pImpl->PrefixDataMap, PrefixData,
-                           SCData, /*Bit=*/1);
-  setValueSubclassData(SCData);
+  if (PrefixData)
+    setHungoffOperand<1>(PrefixData);
+  setValueSubclassDataBit(1, PrefixData != nullptr);
 }
 
 Constant *Function::getPrologueData() const {
-  assert(hasPrologueData());
-  return getFunctionData(this, getContext().pImpl->PrologueDataMap);
+  assert(hasPrologueData() && getNumOperands());
+  return cast<Constant>(Op<2>());
 }
 
 void Function::setPrologueData(Constant *PrologueData) {
-  if (!PrologueData && !hasPrologueData())
+  if (PrologueData)
+    setHungoffOperand<2>(PrologueData);
+  setValueSubclassDataBit(2, PrologueData != nullptr);
+}
+
+void Function::allocHungoffUselist() {
+  // If we've already allocated a uselist, stop here.
+  if (getNumOperands())
     return;
 
-  unsigned SCData = getSubclassDataFromValue();
-  SCData = setFunctionData(this, getContext().pImpl->PrologueDataMap,
-                           PrologueData, SCData, /*Bit=*/2);
-  setValueSubclassData(SCData);
+  allocHungoffUses(3, /*IsPhi=*/ false);
+  setNumHungOffUseOperands(3);
+
+  // Initialize the uselist with placeholder operands to allow traversal.
+  auto *CPN = ConstantPointerNull::get(Type::getInt1PtrTy(getContext(), 0));
+  Op<0>().set(CPN);
+  Op<1>().set(CPN);
+  Op<2>().set(CPN);
+}
+
+template <int Idx>
+void Function::setHungoffOperand(Constant *C) {
+  assert(C && "Cannot set hungoff operand to nullptr");
+  allocHungoffUselist();
+  Op<Idx>().set(C);
+}
+
+void Function::setValueSubclassDataBit(unsigned Bit, bool On) {
+  assert(Bit < 16 && "SubclassData contains only 16 bits");
+  if (On)
+    setValueSubclassData(getSubclassDataFromValue() | (1 << Bit));
+  else
+    setValueSubclassData(getSubclassDataFromValue() & ~(1 << Bit));
 }
 
 void Function::setEntryCount(uint64_t Count) {
   MDBuilder MDB(getContext());
   setMetadata(LLVMContext::MD_prof, MDB.createFunctionEntryCount(Count));
 }
 
 Optional<uint64_t> Function::getEntryCount() const {
   MDNode *MD = getMetadata(LLVMContext::MD_prof);
   if (MD && MD->getOperand(0))
     if (MDString *MDS = dyn_cast<MDString>(MD->getOperand(0)))
       if (MDS->getString().equals("function_entry_count")) {
         ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(1));
         return CI->getValue().getZExtValue();
       }
   return None;
 }
-
-void Function::setPersonalityFn(Constant *C) {
-  if (!C) {
-    if (hasPersonalityFn()) {
-      // Note, the num operands is used to compute the offset of the operand, so
-      // the order here matters.  Clearing the operand then clearing the num
-      // operands ensures we have the correct offset to the operand.
-      Op<0>().set(nullptr);
-      setFunctionNumOperands(0);
-    }
-  } else {
-    // Note, the num operands is used to compute the offset of the operand, so
-    // the order here matters.  We need to set num operands to 1 first so that
-    // we get the correct offset to the first operand when we set it.
-    if (!hasPersonalityFn())
-      setFunctionNumOperands(1);
-    Op<0>().set(C);
-  }
-}

llvm/trunk/lib/IR/LLVMContextImpl.h

#include "llvm/IR/Metadata.def"
   /// Collection of per-function metadata used in this context.
   DenseMap<const Function *, MDAttachmentMap> FunctionMetadata;
 
   /// DiscriminatorTable - This table maps file:line locations to an
   /// integer representing the next DWARF path discriminator to assign to
   /// instructions in different blocks at the same location.
   DenseMap<std::pair<const char *, unsigned>, unsigned> DiscriminatorTable;
 
-  typedef DenseMap<const Function *, ReturnInst *> FunctionDataMapTy;
-
-  /// \brief Mapping from a function to its prefix data, which is stored as the
-  /// operand of an unparented ReturnInst so that the prefix data has a Use.
-  FunctionDataMapTy PrefixDataMap;
-
-  /// \brief Mapping from a function to its prologue data, which is stored as
-  /// the operand of an unparented ReturnInst so that the prologue data has a
-  /// Use.
-  FunctionDataMapTy PrologueDataMap;
-
   int getOrAddScopeRecordIdxEntry(MDNode *N, int ExistingIdx);
   int getOrAddScopeInlinedAtIdxEntry(MDNode *Scope, MDNode *IA,int ExistingIdx);
 
   /// \brief A set of interned tags for operand bundles.  The StringMap maps
   /// bundle tags to their IDs.
   ///
   /// \see LLVMContext::getOperandBundleTagID
   StringMap<uint32_t> BundleTagCache;

llvm/trunk/lib/IR/TypeFinder.cpp

if (const Value *Aliasee = I->getAliasee())
       incorporateValue(Aliasee);
   }
 
   // Get types from functions.
   SmallVector<std::pair<unsigned, MDNode *>, 4> MDForInst;
   for (Module::const_iterator FI = M.begin(), E = M.end(); FI != E; ++FI) {
     incorporateType(FI->getType());
 
-    if (FI->hasPrefixData())
-      incorporateValue(FI->getPrefixData());
-
-    if (FI->hasPrologueData())
-      incorporateValue(FI->getPrologueData());
-
-    if (FI->hasPersonalityFn())
-      incorporateValue(FI->getPersonalityFn());
+    for (const Use &U : FI->operands())
+      incorporateValue(U.get());
 
     // First incorporate the arguments.
     for (Function::const_arg_iterator AI = FI->arg_begin(),
            AE = FI->arg_end(); AI != AE; ++AI)
       incorporateValue(&*AI);
 
     for (Function::const_iterator BB = FI->begin(), E = FI->end();
          BB != E;++BB)

llvm/trunk/lib/Transforms/IPO/GlobalDCE.cpp

if (GlobalVariable *GV = dyn_cast<GlobalVariable>(G)) {
     MarkUsedGlobalsAsNeeded(GA->getAliasee());
   } else {
     // Otherwise this must be a function object.  We have to scan the body of
     // the function looking for constants and global values which are used as
     // operands.  Any operands of these types must be processed to ensure that
     // any globals used will be marked as needed.
     Function *F = cast<Function>(G);
 
-    if (F->hasPrefixData())
-      MarkUsedGlobalsAsNeeded(F->getPrefixData());
-
-    if (F->hasPrologueData())
-      MarkUsedGlobalsAsNeeded(F->getPrologueData());
-
-    if (F->hasPersonalityFn())
-      MarkUsedGlobalsAsNeeded(F->getPersonalityFn());
+    for (Use &U : F->operands())
+      MarkUsedGlobalsAsNeeded(cast<Constant>(U.get()));
 
     for (BasicBlock &BB : *F)
       for (Instruction &I : BB)
         for (Use &U : I.operands())
           if (GlobalValue *GV = dyn_cast<GlobalValue>(U))
             GlobalIsNeeded(GV);
           else if (Constant *C = dyn_cast<Constant>(U))
             MarkUsedGlobalsAsNeeded(C);