Dump function as the only defined function in its module.

[yinma]

Summary

This procedure could dump the module, where the function becomes the only defined function in its module. This is very useful to debug large code base where reducing from source code is difficult, like LTO.

[• rafael]

This is the same as llcm-extract, no?

[yinma]

the functionality, it is similar to llvm-extract. however, it provides a runtime solution to extract a function from a debugger from any point in compilation time like LTO, something after inlining. You can extract function right at the assertion point. llvm-extract only can work on a file. We need a runtime solution.

[bkramer]

In D18524#385156, @yinma wrote:

We need a runtime solution.

Why? Just dump everything into a file and run llvm-extract on it?

[yinma]

Our code base is huge in LTO, it usually take very very long time to dump into a file. With this function, the process would be dramatically faster. I believe this would also benefit other people.

include/llvm/IR/Function.h

/// @}
   void setPrologueData(Constant *PrologueData);
 
   /// Print the function to an output stream with an optional
   /// AssemblyAnnotationWriter.
   void print(raw_ostream &OS, AssemblyAnnotationWriter *AAW = nullptr,
              bool ShouldPreserveUseListOrder = false,
              bool IsForDebug = false) const;
 
+  /// Dump the function as it is the only defined function in module.
+  void dumpAsSingleDefine();
+
   /// 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.
   ///
   void viewCFG() const;
 

lib/IR/Function.cpp

Optional<uint64_t> Function::getEntryCount() const {
   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::dumpAsSingleDefine()
+{
+  typedef std::vector<BasicBlock*> BlockList;
+  typedef std::pair<BlockList*, GlobalValue::LinkageTypes> FuncInfo;
+  typedef std::map<Function*, FuncInfo> FuncMap;
+  FuncMap funcList;
+  // Temporarily change all defined functions to be declaration
+  // except for this one.
+  Module* M = getParent();
+  for (Function &F : *M)
+    if (!F.isDeclaration() && &F != this) {
+      BlockList* blockList = new BlockList;
+      Function::BasicBlockListType &oldBlocks = F.getBasicBlockList();
+      while (!oldBlocks.empty()) {
+        blockList->push_back(&oldBlocks.back());
+        oldBlocks.remove(oldBlocks.back());
+      }
+      funcList[&F]= std::make_pair(blockList, F.getLinkage());
+      F.setLinkage(ExternalLinkage);
+    }
+
+  M->dump();
+
+  // Restore everything back.
+  for (auto it : funcList) {
+    Function* F = it.first;
+    BlockList* list = it.second.first;
+    GlobalValue::LinkageTypes LT = it.second.second;
+    Function::BasicBlockListType &oldBlocks = F->getBasicBlockList();
+    while(!list->empty()) {
+      oldBlocks.push_back(list->back());
+      list->pop_back();
+    }
+    F->setLinkage(LT);
+  }
+}
+