[IR] Handle dbg call site through the middle-end pipeline

[djtodoro]

Summary

Add support when combining call site metadata.

In such situation it creates a simple call site that has no description about call site parameters.

Authors: @asowda, @NikolaPrica, @djtodoro, @ivanbaev

include/llvm/IR/DIBuilder.h

public:
     ///                    scope.
     /// \param VD          A variable declaration pointer trough which is
     ///                    argument passed.
     DICallSiteParam * createCallSiteParam(unsigned ArgNo,
                                           DIExpression *DIExpr,
                                           DIScope *Scope = nullptr,
                                           VarDecl VD = nullptr);
 
+    /// When we loose order of some function's parameter we create new
+    /// simple call site in order to be able to keep tracing it after
+    /// ISel phase trough its location. To secure that every parameter
+    /// has its own call site param metadata, even the simplest, we
+    /// call this function.
+    /// \param DCS          Old call site that contains number of required
+    ///                     new empty call site parameter metadata
+    /// \param Scope        Scope of caller function used to determeine
+    ///                     from which DISubprogram given DICallSite should
+    ///                     be deleted.
+    /// \param Context      New Context for metadata.
+    DICallSite *createSimpleCallSite(DICallSite *DCS, DILocalScope *Scope,
+                                     LLVMContext &Context);
+
+    /// Erase call site from subprogram that is contains given scope.
+    /// \param CallSite    CallSite pointer that should be droped from
+    //                     following function scope.
+    //  \param Scope       Scope that should be used to determine from
+    //                     which DISubprogram given CallSite should be
+    //                     deleted.
+    void eraseCallSite(DICallSite *CallSite, DIScope *Scope);
+
     /// This creates new descriptor for a namespace with the specified
     /// parent scope.
     /// \param Scope       Namespace scope
     /// \param Name        Name of this namespace
     /// \param ExportSymbols True for C++ inline namespaces.
     DINamespace *createNameSpace(DIScope *Scope, StringRef Name,
                                  bool ExportSymbols);
 

include/llvm/IR/DebugInfoMetadata.h

public:
   }
   Metadata *getRawParams() const { return getOperand(2); }
   Metadata *getRawCalledSubprogram() const { return getOperand(3); }
 
   bool isValidLocationForIntrinsic(const DILocation *DL) const {
     return DL && getScope()->getSubprogram() == DL->getScope()->getSubprogram();
   }
 
+  // Create DICallSite that has same number of simple call site parameters as
+  // CS.
+  static DICallSite *getTrivialCallSite(const DICallSite *CS,
+                                        DILocalScope *NewScope,
+                                        LLVMContext &Context);
+
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == DICallSiteKind;
   }
 };
 
 class DICallSiteParam : public DINode {
   friend class LLVMContextImpl;
   friend class MDNode;

lib/IR/DIBuilder.cpp

if (VD != nullptr) {
     if (!DILV)
       Expr = DIExpression::get(VMContext, {});
     else
       return DICallSiteParam::get(VMContext, ArgNo, DILV, Expr);
   }
   return DICallSiteParam::get(VMContext, ArgNo, Expr);
 }
 
+void DIBuilder::eraseCallSite(DICallSite *CallSite, DIScope *Scope) {
+  DISubprogram *Fn = getDISubprogram(Scope);
+  assert(Fn && "Missing subprogram for callsite");
+  DINodeArray OldElements = Fn->getRetainedNodes();
+  SmallVector<Metadata *, 16> Elements;
+
+  for (unsigned i = 0; i < OldElements.size(); ++i) {
+    if (DICallSite *CS = dyn_cast_or_null<DICallSite>(OldElements[i])) {
+      if (CS != CallSite)
+        Elements.push_back(CS);
+    } else
+      Elements.push_back(OldElements[i]);
+  }
+
+  DINodeArray AV = getOrCreateArray(Elements);
+  Fn->replaceElements(AV);
+}
+
+DICallSite *DIBuilder::createSimpleCallSite(DICallSite *DCS,
+                                            DILocalScope *Scope,
+                                            LLVMContext &Context) {
+  auto *Node = DICallSite::getTrivialCallSite(DCS, Scope, Context);
+
+  DISubprogram *Fn = getDISubprogram(Scope);
+  assert(Fn && "Missing subprogram for callsite");
+  DINodeArray Elements = Fn->getRetainedNodes();
+  SmallVector<Metadata *, 16> NewElements;
+  for (unsigned i = 0; i < Elements.size(); ++i)
+    NewElements.push_back(Elements[i]);
+  NewElements.push_back(DCS);
+
+  DINodeArray AV = getOrCreateArray(NewElements);
+  Fn->replaceElements(AV);
+
+  return Node;
+}
+
 DISubprogram *DIBuilder::createTempFunctionFwdDecl(
     DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *File,
     unsigned LineNo, DISubroutineType *Ty, unsigned ScopeLine,
     DINode::DIFlags Flags, DISubprogram::DISPFlags SPFlags,
     DITemplateParameterArray TParams, DISubprogram *Decl,
     DITypeArray ThrownTypes) {
   bool IsDefinition = SPFlags & DISubprogram::SPFlagDefinition;
   return DISubprogram::getTemporary(VMContext, getNonCompileUnitScope(Context),

lib/IR/DebugInfoMetadata.cpp

DICallSite *DICallSite::getImpl(LLVMContext &Context, Metadata *Scope,
   assert(Scope && "Expected scope");
 
   DEFINE_GETIMPL_LOOKUP(DICallSite,
                         (Line, Scope, File, Params, CalledSubprogram));
   Metadata *Ops[] = {Scope, File, Params, CalledSubprogram};
   DEFINE_GETIMPL_STORE(DICallSite, (Line), Ops);
 }
 
+DICallSite *DICallSite::getTrivialCallSite(const DICallSite *CS,
+                                           DILocalScope *NewScope,
+                                           LLVMContext &Context) {
+  DIExpression *Expr = DIExpression::get(CS->getContext(), {});
+  SmallVector<llvm::Metadata *, 8> CallSiteParams;
+  for (unsigned ArgNo = 1; ArgNo <= CS->getParameters().size(); ArgNo++)
+    CallSiteParams.push_back(
+        DICallSiteParam::get(CS->getContext(), ArgNo, Expr));
+  llvm::DINodeArray NewParamArray =
+      MDTuple::get(CS->getContext(), CallSiteParams);
+  return DICallSite::get(Context, NewScope, CS->getFile(), NewParamArray, 1,
+                         CS->getCalledSubprogram());
+}
+
 DICallSiteParam *DICallSiteParam::getImpl(LLVMContext &Context,
                                           unsigned ArgNo, Metadata *Var,
                                           Metadata *Expr, StorageType Storage,
                                           bool ShouldCreate) {
   DEFINE_GETIMPL_LOOKUP(DICallSiteParam, (ArgNo, Var, Expr));
   Metadata *Ops[] = {Var, Expr};
   DEFINE_GETIMPL_STORE(DICallSiteParam, (ArgNo), Ops);
 }

lib/Transforms/Scalar/PartiallyInlineLibCalls.cpp

static bool optimizeSQRT(CallInst *Call, Function *CalledFunc,
   PHINode *Phi = Builder.CreatePHI(Ty, 2);
   Call->replaceAllUsesWith(Phi);
 
   // Create basic block LibCallBB and insert a call to library function sqrt.
   BasicBlock *LibCallBB = BasicBlock::Create(CurrBB.getContext(), "call.sqrt",
                                              CurrBB.getParent(), JoinBB);
   Builder.SetInsertPoint(LibCallBB);
   Instruction *LibCall = Call->clone();
+  // Do not track call site info from partially inlined lib calls.
+  if (LibCall->getMetadata(LLVMContext::MD_call_site))
+    LibCall->setMetadata(LLVMContext::MD_call_site, nullptr);
   Builder.Insert(LibCall);
   Builder.CreateBr(JoinBB);
 
   // Add attribute "readnone" so that backend can use a native sqrt instruction
   // for this call. Insert a FP compare instruction and a conditional branch
   // at the end of CurrBB.
   Call->addAttribute(AttributeList::FunctionIndex, Attribute::ReadNone);
   CurrBB.getTerminator()->eraseFromParent();

lib/Transforms/Utils/Local.cpp

for (const auto &MD : Metadata) {
     MDNode *KMD = MD.second;
 
     switch (Kind) {
       default:
         K->setMetadata(Kind, nullptr); // Remove unknown metadata
         break;
       case LLVMContext::MD_dbg:
         llvm_unreachable("getAllMetadataOtherThanDebugLoc returned a MD_dbg");
+      case LLVMContext::MD_call_site: {
+        DILocalScope *Scope = K->getDebugLoc()->getScope();
+        auto &M = *(K->getModule());
+        DIBuilder DIB(M, false);
+
+        K->setMetadata(LLVMContext::MD_call_site,
+                       DIB.createSimpleCallSite(cast<DICallSite>(JMD), Scope,
+                                                K->getContext()));
+        DIB.eraseCallSite(cast<DICallSite>(JMD), Scope);
+        DIB.eraseCallSite(cast<DICallSite>(KMD), Scope);
+        break;
+      }
       case LLVMContext::MD_tbaa:
         K->setMetadata(Kind, MDNode::getMostGenericTBAA(JMD, KMD));
         break;
       case LLVMContext::MD_alias_scope:
         K->setMetadata(Kind, MDNode::getMostGenericAliasScope(JMD, KMD));
         break;
       case LLVMContext::MD_noalias:
       case LLVMContext::MD_mem_parallel_loop_access:

 
 void llvm::combineMetadataForCSE(Instruction *K, const Instruction *J,
                                  bool KDominatesJ) {
   unsigned KnownIDs[] = {
       LLVMContext::MD_tbaa,            LLVMContext::MD_alias_scope,
       LLVMContext::MD_noalias,         LLVMContext::MD_range,
       LLVMContext::MD_invariant_load,  LLVMContext::MD_nonnull,
       LLVMContext::MD_invariant_group, LLVMContext::MD_align,
-      LLVMContext::MD_dereferenceable,
+      LLVMContext::MD_dereferenceable, LLVMContext::MD_call_site,
       LLVMContext::MD_dereferenceable_or_null,
       LLVMContext::MD_access_group};
   combineMetadata(K, J, KnownIDs, KDominatesJ);
 }
 
 void llvm::patchReplacementInstruction(Instruction *I, Value *Repl) {
   auto *ReplInst = dyn_cast<Instruction>(Repl);
   if (!ReplInst)