Emit DICallSite and DICallSiteParam metadata

[djtodoro]

Summary

Attach on call/invoke IR instructions '!call_site' MD node that references on particular DICallSite metadata.

Also this creates DICallsite and DICallSiteParam metadata.

An example of call site metadata:
!DICallSite(scope: !7, file: !8, parameters: !15, line: 8, calledSubprogram: !18)
Called subprogram references to DISubprogram of a called function. For external functions, we generate new DISubprogram at this place.

An example of call site parameter metadata:
!DICallSiteParam(argno: 1, var: !20, expr: !DIExpression())
DIExpression within DICallSiteparam is used as backup location information when primary parameter's location is lost. This basically describes technique of jumping in parent frame and printing certain argument expressions. Expressions with multiple variables (e.g. foo(a+b)) is not supported for now.

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

include/clang/AST/Decl.h

public:
   }
 
   bool isInlineDefinitionExternallyVisible() const;
 
   bool isMSExternInline() const;
 
   bool doesDeclarationForceExternallyVisibleDefinition() const;
 
+  bool isStatic() const { return getStorageClass() == SC_Static; }
+
+  bool isExtern() const { return getStorageClass() == SC_Extern; }
+
   /// Whether this function declaration represents an C++ overloaded
   /// operator, e.g., "operator+".
   bool isOverloadedOperator() const {
     return getOverloadedOperator() != OO_None;
   }
 
   OverloadedOperatorKind getOverloadedOperator() const;
 

lib/CodeGen/CGBlocks.cpp

void CodeGenFunction::setBlockContextParameter(const ImplicitParamDecl *D,
   // debug info at -O0. The mem2reg pass will eliminate it when optimizing.
   Address alloc = CreateMemTemp(D->getType(), D->getName() + ".addr");
   Builder.CreateStore(arg, alloc);
   if (CGDebugInfo *DI = getDebugInfo()) {
     if (CGM.getCodeGenOpts().getDebugInfo() >=
         codegenoptions::LimitedDebugInfo) {
       DI->setLocation(D->getLocation());
       DI->EmitDeclareOfBlockLiteralArgVariable(
-          *BlockInfo, D->getName(), argNum,
+          *BlockInfo, D, argNum,
           cast<llvm::AllocaInst>(alloc.getPointer()), Builder);
     }
   }
 
   SourceLocation StartLoc = BlockInfo->getBlockExpr()->getBody()->getBeginLoc();
   ApplyDebugLocation Scope(*this, StartLoc);
 
   // Instead of messing around with LocalDeclMap, just set the value

lib/CodeGen/CGDebugInfo.h

 #define LLVM_CLANG_LIB_CODEGEN_CGDEBUGINFO_H
 
 #include "CGBuilder.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExternalASTSource.h"
 #include "clang/AST/Type.h"
 #include "clang/AST/TypeOrdering.h"
+#include "clang/AST/GlobalDecl.h"
 #include "clang/Basic/CodeGenOptions.h"
 #include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/IR/DIBuilder.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/ValueHandle.h"
public:
   /// Emit metadata to indicate the beginning of a new lexical block
   /// and push the block onto the stack.
   void EmitLexicalBlockStart(CGBuilderTy &Builder, SourceLocation Loc);
 
   /// Emit metadata to indicate the end of a new lexical block and pop
   /// the current block.
   void EmitLexicalBlockEnd(CGBuilderTy &Builder, SourceLocation Loc);
 
+  /// Emit DICallSite for a call.
+  llvm::DICallSite* EmitCallSite(const Decl *D, const CallExpr *E,
+                                 llvm::DISubprogram* CalledSubprogram,
+                                 CGBuilderTy &Builder,
+                                 unsigned NumIRInstrArgs);
+
   /// Emit call to \c llvm.dbg.declare for an automatic variable
   /// declaration.
   /// Returns a pointer to the DILocalVariable associated with the
   /// llvm.dbg.declare, or nullptr otherwise.
   llvm::DILocalVariable *EmitDeclareOfAutoVariable(const VarDecl *Decl,
                                                    llvm::Value *AI,
                                                    CGBuilderTy &Builder);
 
public:
   /// Emit call to \c llvm.dbg.declare for an argument variable
   /// declaration.
   void EmitDeclareOfArgVariable(const VarDecl *Decl, llvm::Value *AI,
                                 unsigned ArgNo, CGBuilderTy &Builder);
 
   /// Emit call to \c llvm.dbg.declare for the block-literal argument
   /// to a block invocation function.
   void EmitDeclareOfBlockLiteralArgVariable(const CGBlockInfo &block,
-                                            StringRef Name, unsigned ArgNo,
+                                            const ImplicitParamDecl *VD,
+                                            unsigned ArgNo,
                                             llvm::AllocaInst *LocalAddr,
                                             CGBuilderTy &Builder);
 
   /// Emit information about a global variable.
   void EmitGlobalVariable(llvm::GlobalVariable *GV, const VarDecl *Decl);
 
   /// Emit a constant global variable's debug info.
   void EmitGlobalVariable(const ValueDecl *VD, const APValue &Init);
public:
   llvm::DIType *getOrCreateRecordType(QualType Ty, SourceLocation L);
 
   /// Emit an Objective-C interface type standalone debug info.
   llvm::DIType *getOrCreateInterfaceType(QualType Ty, SourceLocation Loc);
 
   /// Emit standalone debug info for a type.
   llvm::DIType *getOrCreateStandaloneType(QualType Ty, SourceLocation Loc);
 
+  /// Get DISubprogram for an extern function.
+  llvm::DISubprogram *getFunctionExternDecl(GlobalDecl GD, SourceLocation Loc,
+                                            QualType FnType);
+
+  llvm::DISubprogram *getFunctionFwdDeclaration(GlobalDecl FD) {
+    return getFunctionForwardDeclaration(FD);
+  }
+
   void completeType(const EnumDecl *ED);
   void completeType(const RecordDecl *RD);
   void completeRequiredType(const RecordDecl *RD);
   void completeClassData(const RecordDecl *RD);
   void completeClass(const RecordDecl *RD);
 
   void completeTemplateDefinition(const ClassTemplateSpecializationDecl &SD);
   void completeUnusedClass(const CXXRecordDecl &D);

lib/CodeGen/CGDebugInfo.cpp

 #include "CodeGenFunction.h"
 #include "CodeGenModule.h"
 #include "ConstantEmitter.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclFriend.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Expr.h"
+#include "clang/AST/StmtVisitor.h"
 #include "clang/AST/RecordLayout.h"
 #include "clang/Basic/CodeGenOptions.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/Version.h"
 #include "clang/Frontend/FrontendOptions.h"
 #include "clang/Lex/HeaderSearchOptions.h"
 #include "clang/Lex/ModuleMap.h"

 }
 
 void CGDebugInfo::EmitInlineFunctionEnd(CGBuilderTy &Builder) {
   assert(CurInlinedAt && "unbalanced inline scope stack");
   EmitFunctionEnd(Builder, nullptr);
   setInlinedAt(llvm::DebugLoc(CurInlinedAt).getInlinedAt());
 }
 
+llvm::DISubprogram *CGDebugInfo::getFunctionExternDecl(GlobalDecl GD,
+                                                       SourceLocation Loc,
+                                                       QualType FnType) {
+  StringRef Name;
+  StringRef LinkageName;
+
+  const Decl *D = GD.getDecl();
+  if (!D)
+    return nullptr;
+
+  llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
+  llvm::DIFile *Unit = getOrCreateFile(Loc);
+  llvm::DIScope *FDContext = Unit;
+  llvm::DINodeArray TParamsArray;
+  if (isa<FunctionDecl>(D)) {
+    // If there is a DISubprogram for this function available then use it.
+    collectFunctionDeclProps(GD, Unit, Name, LinkageName, FDContext,
+                             TParamsArray, Flags);
+  } else if (const auto *OMD = dyn_cast<ObjCMethodDecl>(D)) {
+    Name = getObjCMethodName(OMD);
+    Flags |= llvm::DINode::FlagPrototyped;
+  } else {
+    llvm_unreachable("not a function or ObjC method");
+  }
+
+  if (!Name.empty() && Name[0] == '\01')
+    Name = Name.substr(1);
+
+  if (D->isImplicit()) {
+    Flags |= llvm::DINode::FlagArtificial;
+    // Artificial functions without a location should not silently reuse CurLoc.
+    if (Loc.isInvalid())
+      CurLoc = SourceLocation();
+  }
+
+  unsigned LineNo = getLineNumber(Loc);
+  unsigned ScopeLine = 0;
+
+  llvm::DISubprogram::DISPFlags SPFlags = llvm::DISubprogram::SPFlagZero;
+  if (CGM.getLangOpts().Optimize)
+    SPFlags |= llvm::DISubprogram::SPFlagOptimized;
+  // We want just func declaration.
+  SPFlags &= ~llvm::DISubprogram::SPFlagDefinition;
+
+  llvm::DISubprogram *SP = DBuilder.createFunction(
+      FDContext, Name, LinkageName, Unit, LineNo, nullptr, ScopeLine, Flags,
+      SPFlags, TParamsArray.get(), getFunctionDeclaration(D), nullptr, true);
+
+  return SP;
+}
+
 void CGDebugInfo::EmitLocation(CGBuilderTy &Builder, SourceLocation Loc) {
   // Update our current location
   setLocation(Loc);
 
   if (CurLoc.isInvalid() || CurLoc.isMacroID() || LexicalBlockStack.empty())
     return;
 
   llvm::MDNode *Scope = LexicalBlockStack.back();
llvm::DILocalVariable *CGDebugInfo::EmitDeclare(const VarDecl *VD,
   llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
   if (VD->isImplicit())
     Flags |= llvm::DINode::FlagArtificial;
 
   auto &CGOpts = CGM.getCodeGenOpts();
   if (CGOpts.EnableParamEntryValues && !VD->getIsValChanged())
     Flags |= llvm::DINode::FlagVariableNotChanged;
 
-
   auto Align = getDeclAlignIfRequired(VD, CGM.getContext());
 
   unsigned AddressSpace = CGM.getContext().getTargetAddressSpace(VD->getType());
   AppendAddressSpaceXDeref(AddressSpace, Expr);
 
   // If this is implicit parameter of CXXThis or ObjCSelf kind, then give it an
   // object pointer flag.
   if (const auto *IPD = dyn_cast<ImplicitParamDecl>(VD)) {
if (RD->isUnion() && RD->isAnonymousStructOrUnion()) {
         StringRef FieldName = Field->getName();
 
         // Ignore unnamed fields. Do not ignore unnamed records.
         if (FieldName.empty() && !isa<RecordType>(Field->getType()))
           continue;
 
         // Use VarDecl's Tag, Scope and Line number.
         auto FieldAlign = getDeclAlignIfRequired(Field, CGM.getContext());
+
         auto *D = DBuilder.createAutoVariable(
-            Scope, FieldName, Unit, Line, FieldTy, CGM.getLangOpts().Optimize,
+            Scope, FieldName, Unit, Line, FieldTy,
             Flags | llvm::DINode::FlagArtificial, FieldAlign);
 
+        if (CGM.getLangOpts().Optimize)
+          DBuilder.preserveVariable(Scope, D, VD);
+
         // Insert an llvm.dbg.declare into the current block.
         DBuilder.insertDeclare(
             Storage, D, DBuilder.createExpression(Expr),
             llvm::DebugLoc::get(Line, Column, Scope, CurInlinedAt),
             Builder.GetInsertBlock());
       }
     }
   }
 
   // Create the descriptor for the variable.
   auto *D = ArgNo ? DBuilder.createParameterVariable(
-                        Scope, Name, *ArgNo, Unit, Line, Ty,
-                        CGM.getLangOpts().Optimize, Flags)
+                        Scope, Name, *ArgNo, Unit, Line, Ty, Flags)
                   : DBuilder.createAutoVariable(Scope, Name, Unit, Line, Ty,
-                                                CGM.getLangOpts().Optimize,
                                                 Flags, Align);
 
+  if (CGM.getLangOpts().Optimize)
+    DBuilder.preserveVariable(Scope, D, VD);
+
   // Insert an llvm.dbg.declare into the current block.
   DBuilder.insertDeclare(Storage, D, DBuilder.createExpression(Expr),
                          llvm::DebugLoc::get(Line, Column, Scope, CurInlinedAt),
                          Builder.GetInsertBlock());
 
   return D;
 }
 
auto *L =
       DBuilder.createLabel(Scope, Name, Unit, Line, CGM.getLangOpts().Optimize);
 
   // Insert an llvm.dbg.label into the current block.
   DBuilder.insertLabel(L,
                        llvm::DebugLoc::get(Line, Column, Scope, CurInlinedAt),
                        Builder.GetInsertBlock());
 }
 
+// Algorithm for producing functions argument representation. Result of
+// algorithm is supposed to be used for creating DICallSiteParam. Current
+// version supports only simple cases with one variable and expression over
+// that variable. If argument is constant value only expession is provided.
+// Expression is given in form of DW_OP codes. Algorithm is not interested in
+// representing argument that is another function call. Current version
+// supports only expression over one variable.
+// TODO: Next version should be able to  represent expressions over more
+// variables but that requires changing DICallSiteParameter
+// and derived class from DIExpression that could potentially represent
+// such expressions.
+
+namespace {
+/// Represent expression in terms of dwarf expression over variable. If there
+/// is no variable expression must be constant.
+struct DwarfExprRepresentation
+    : ConstStmtVisitor<DwarfExprRepresentation, bool> {
+  const ASTContext *Ctx;
+  const VarDecl *VD;
+  SmallVector<uint64_t, 4> Ops;
+
+  DwarfExprRepresentation() = default;
+
+  void clean() {
+    VD = nullptr;
+    Ops.clear();
+  }
+
+  void get(const VarDecl **Var, SmallVectorImpl<uint64_t> &Operands) {
+    *Var = VD;
+    VD = nullptr;
+    Operands = std::move(Ops);
+  }
+
+  void setContext(const ASTContext &Context) { Ctx = &Context; };
+
+  bool VisitExpr(const Expr *Exp) { return false; }
+
+  bool VisitImplicitCastExpr(const ImplicitCastExpr *Exp) {
+    return Visit(Exp->getSubExpr());
+  }
+
+  bool VisitBinaryOperator(const BinaryOperator *E) {
+    const Expr *LHS = E->getLHS();
+    const Expr *RHS = E->getRHS();
+
+    if (Visit(LHS) && Visit(RHS)) {
+      if (VD) {
+        switch (E->getOpcode()) {
+        case BO_Add:
+          Ops.push_back(llvm::dwarf::DW_OP_plus);
+          return true;
+        case BO_Mul:
+          Ops.push_back(llvm::dwarf::DW_OP_mul);
+          return true;
+        case BO_Div:
+          Ops.push_back(llvm::dwarf::DW_OP_div);
+          return true;
+        case BO_Sub:
+          Ops.push_back(llvm::dwarf::DW_OP_minus);
+          return true;
+        default:
+          return false;
+        }
+      } else {
+        // If VD is null then this is constant expression. Evaluate it and
+        // represent the result value.
+        llvm::APSInt Result;
+        Ops.clear();
+        if (E->isIntegerConstantExpr(Result, *Ctx)) {
+          int64_t Value = Result.getExtValue();
+          if (Value >= 0 && Value <= 31)
+            Ops.push_back(llvm::dwarf::DW_OP_lit0 + Value);
+          else {
+            Ops.push_back(Value < 0 ? llvm::dwarf::DW_OP_consts
+                                    : llvm::dwarf::DW_OP_constu);
+            Ops.push_back(Value);
+          }
+          return true;
+        }
+      }
+    }
+
+    // Clear all DWARF ops of unsupported expressions.
+    Ops.clear();
+
+    return false;
+  }
+
+  bool VisitUnaryDeref(const UnaryOperator *E) {
+    if (!Visit(E->getSubExpr()))
+      return false;
+    Ops.push_back(llvm::dwarf::DW_OP_deref);
+    return true;
+  }
+
+  bool VisitUnaryAddrOf(const UnaryOperator *E) {
+    if (!Visit(E->getSubExpr()))
+      return false;
+    Ops.push_back(llvm::dwarf::DW_OP_push_object_address);
+    return true;
+  }
+
+  bool VisitUnaryMinus(const UnaryOperator *E) {
+    // If the expression is '-- const'.
+    if (Ops.size() && Ops.back() == llvm::dwarf::DW_OP_neg)
+      return false;
+    if (!Visit(E->getSubExpr()))
+      return false;
+    Ops.push_back(llvm::dwarf::DW_OP_neg);
+    return true;
+  }
+
+  bool VisitDeclRefExpr(const DeclRefExpr *E) {
+    if (const VarDecl *VarD = dyn_cast<VarDecl>(E->getDecl())) {
+      if (!VD && !VarD->hasGlobalStorage()) {
+        VD = VarD;
+        return true;
+      }
+    }
+    VD = nullptr;
+    return false;
+  }
+
+  bool VisitIntegerLiteral(const IntegerLiteral *E) {
+    uint64_t Value = *E->getValue().getRawData();
+    if (Value <= 31)
+      Ops.push_back(llvm::dwarf::DW_OP_lit0 + Value);
+    else {
+      Ops.push_back(llvm::dwarf::DW_OP_constu);
+      Ops.push_back(Value);
+    }
+    return true;
+  }
+};
+} // end anonymous namespace
+
+llvm::DICallSite *
+CGDebugInfo::EmitCallSite(const Decl *D, const CallExpr *E,
+                          llvm::DISubprogram *CalledSubprogram,
+                          CGBuilderTy &Builder, unsigned NumIRInstrArgs) {
+  if (D->hasAttr<NoDebugAttr>())
+    return nullptr;
+
+  SmallVector<llvm::Metadata *, 8> CallSiteParams;
+  static DwarfExprRepresentation EvalDwarfOps;
+  EvalDwarfOps.setContext(CGM.getContext());
+  auto *Scope = cast<llvm::DIScope>(LexicalBlockStack.back());
+  unsigned ArgNo = 1;
+  if (NumIRInstrArgs > E->getNumArgs()) {
+    llvm::DIExpression *Expr = DBuilder.createExpression();
+    for (; ArgNo <= NumIRInstrArgs; ++ArgNo) {
+      llvm::DICallSiteParam *DCSP = DBuilder.createCallSiteParam(ArgNo, Expr);
+      CallSiteParams.push_back(DCSP);
+    }
+  } else {
+    if (isa<CXXMethodDecl>(D)) {
+      llvm::DIExpression *Expr = DBuilder.createExpression();
+      llvm::DICallSiteParam *DCSP = DBuilder.createCallSiteParam(ArgNo, Expr);
+      CallSiteParams.push_back(DCSP);
+      ArgNo++;
+    }
+    for (auto Arg : E->arguments()) {
+      SmallVector<uint64_t, 4> Ops;
+      const VarDecl *VD = nullptr;
+      if (EvalDwarfOps.Visit(Arg))
+        EvalDwarfOps.get(&VD, Ops);
+      EvalDwarfOps.clean();
+
+      llvm::DIExpression *Expr = DBuilder.createExpression(Ops);
+
+      llvm::DICallSiteParam *DCSP = nullptr;
+      if (VD)
+        DCSP = DBuilder.createCallSiteParam(ArgNo, Expr, Scope, VD);
+      else
+        DCSP = DBuilder.createCallSiteParam(ArgNo, Expr);
+
+      CallSiteParams.push_back(DCSP);
+      ArgNo++;
+    }
+  }
+
+  llvm::DINodeArray ParamArray = DBuilder.getOrCreateArray(CallSiteParams);
+  llvm::DIFile *Unit = getOrCreateFile(E->getExprLoc());
+
+  // Get location information.
+  unsigned Line = getLineNumber(E->getExprLoc());
+
+  // Create the descriptor for the call site.
+  auto *CS = DBuilder.createCallSite(Scope, Unit, Line, CalledSubprogram,
+                                     ParamArray, CGM.getLangOpts().Optimize);
+
+  return CS;
+}
+
 llvm::DIType *CGDebugInfo::CreateSelfType(const QualType &QualTy,
                                           llvm::DIType *Ty) {
   llvm::DIType *CachedTy = getTypeOrNull(QualTy);
   if (CachedTy)
     Ty = CachedTy;
   return DBuilder.createObjectPointerType(Ty);
 }
 
if (isByRef) {
     offset = CGM.getContext().toCharUnitsFromBits(XOffset);
     addr.push_back(offset.getQuantity());
   }
 
   // Create the descriptor for the variable.
   auto Align = getDeclAlignIfRequired(VD, CGM.getContext());
   auto *D = DBuilder.createAutoVariable(
       cast<llvm::DILocalScope>(LexicalBlockStack.back()), VD->getName(), Unit,
-      Line, Ty, false, llvm::DINode::FlagZero, Align);
+      Line, Ty, llvm::DINode::FlagZero, Align);
 
   // Insert an llvm.dbg.declare into the current block.
   auto DL =
       llvm::DebugLoc::get(Line, Column, LexicalBlockStack.back(), CurInlinedAt);
   auto *Expr = DBuilder.createExpression(addr);
   if (InsertPoint)
     DBuilder.insertDeclare(Storage, D, Expr, DL, InsertPoint);
   else
Fields.push_back(createFieldType(
         Context.getPointerType(Block.NeedsCopyDispose
                                    ? Context.getBlockDescriptorExtendedType()
                                    : Context.getBlockDescriptorType()),
         Loc, AS_public, BlockLayout.getElementOffsetInBits(4), Unit, Unit));
   }
 }
 
 void CGDebugInfo::EmitDeclareOfBlockLiteralArgVariable(const CGBlockInfo &block,
-                                                       StringRef Name,
+                                                       const ImplicitParamDecl *VD,
                                                        unsigned ArgNo,
                                                        llvm::AllocaInst *Alloca,
                                                        CGBuilderTy &Builder) {
+  StringRef Name = VD->getName();
   assert(DebugKind >= codegenoptions::LimitedDebugInfo);
   ASTContext &C = CGM.getContext();
   const BlockDecl *blockDecl = block.getBlockDecl();
 
   // Collect some general information about the block's location.
   SourceLocation loc = blockDecl->getCaretLocation();
   llvm::DIFile *tunit = getOrCreateFile(loc);
   unsigned line = getLineNumber(loc);
void CGDebugInfo::EmitDeclareOfBlockLiteralArgVariable(const CGBlockInfo &block,
   type = DBuilder.createPointerType(type, CGM.PointerWidthInBits);
 
   // Get overall information about the block.
   llvm::DINode::DIFlags flags = llvm::DINode::FlagArtificial;
   auto *scope = cast<llvm::DILocalScope>(LexicalBlockStack.back());
 
   // Create the descriptor for the parameter.
   auto *debugVar = DBuilder.createParameterVariable(
-      scope, Name, ArgNo, tunit, line, type, CGM.getLangOpts().Optimize, flags);
+       scope, Name, ArgNo, tunit, line, type, flags);
+  if (CGM.getLangOpts().Optimize)
+    DBuilder.preserveVariable(scope, debugVar, VD);
 
   // Insert an llvm.dbg.declare into the current block.
   DBuilder.insertDeclare(Alloca, debugVar, DBuilder.createExpression(),
                          llvm::DebugLoc::get(line, column, scope, CurInlinedAt),
                          Builder.GetInsertBlock());
 }
 
 llvm::DIDerivedType *

lib/CodeGen/CGExpr.cpp

 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/NSAPI.h"
 #include "clang/Basic/CodeGenOptions.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/IR/DataLayout.h"
+#include "llvm/IR/Function.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/MDBuilder.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Transforms/Utils/SanitizerStats.h"
 
if (isa<FunctionNoProtoType>(FnType) || Chain) {
     llvm::Type *CalleeTy = getTypes().GetFunctionType(FnInfo);
     CalleeTy = CalleeTy->getPointerTo();
 
     llvm::Value *CalleePtr = Callee.getFunctionPointer();
     CalleePtr = Builder.CreateBitCast(CalleePtr, CalleeTy, "callee.knr.cast");
     Callee.setFunctionPointer(CalleePtr);
   }
 
-  return EmitCall(FnInfo, Callee, ReturnValue, Args, nullptr, E->getExprLoc());
+  llvm::CallBase *callOrInvoke = nullptr;
+  RValue Call = EmitCall(FnInfo, Callee, ReturnValue, Args, &callOrInvoke,
+                         E->getExprLoc());
+
+  // Generate all necessary debug information about call sites and its
+  // parameters.
+  auto &CGOpts = CGM.getCodeGenOpts();
+  if (CGOpts.EnableParamEntryValues && CGM.getLangOpts().Optimize &&
+      callOrInvoke) {
+
+    if (CGDebugInfo *DI = getDebugInfo()) {
+      if (CGOpts.getDebugInfo() >= codegenoptions::LimitedDebugInfo &&
+          CGOpts.getDebuggerTuning() == llvm::DebuggerKind::GDB &&
+          CGOpts.DwarfVersion == 4) {
+        DI->setLocation(CurCodeDecl->getLocation());
+        unsigned IRCallNumArgs = callOrInvoke->getNumArgOperands();
+        llvm::DISubprogram *CalledSubprogram = nullptr;
+
+        if (auto *Func = callOrInvoke->getCalledFunction())
+          CalledSubprogram = Func->getSubprogram();
+
+        if (const FunctionDecl *CalledFD =
+                dyn_cast_or_null<FunctionDecl>(TargetDecl)) {
+          if (!CalledFD->isInlined() && !CalledSubprogram) {
+            if (CalledFD->isStatic())
+              CalledSubprogram = DI->getFunctionFwdDeclaration(CalledFD);
+            else
+              CalledSubprogram = DI->getFunctionExternDecl(
+                  CalledFD, CalledFD->getLocation(), CalleeType);
+          }
+        }
+
+        llvm::DICallSite *CS = DI->EmitCallSite(
+            CurCodeDecl, E, CalledSubprogram, Builder, IRCallNumArgs);
+        callOrInvoke->setMetadata(llvm::LLVMContext::MD_call_site, CS);
+      }
+    }
+  }
+
+  return Call;
 }
 
 LValue CodeGenFunction::
 EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E) {
   Address BaseAddr = Address::invalid();
   if (E->getOpcode() == BO_PtrMemI) {
     BaseAddr = EmitPointerWithAlignment(E->getLHS());
   } else {

test/CodeGen/dbginfo-callsite-constant-params.c

+// RUN: %clang -g -O2 -femit-param-entry-values -S -emit-llvm %s -o -| FileCheck %s
+// CHECK: !DICallSiteParam(argno: 1, expr: !DIExpression(DW_OP_consts, 18446744073709551594))
+// CHECK: !DICallSiteParam(argno: 1, expr: !DIExpression(DW_OP_constu, 44))
+// CHECK: !DICallSiteParam(argno: 1, expr: !DIExpression(DW_OP_lit14))
+extern int foo1(unsigned);
+#define NUMBER  11
+int global;
+void baa() {
+  global = foo1(NUMBER - 33);
+  global += foo1(NUMBER + 33);
+  global += foo1(NUMBER + 3);
+}

test/CodeGen/dbginfo-callsite-unsupported-params.c

+// RUN: %clang -g -O2 -femit-param-entry-values -S -emit-llvm %s -o -| FileCheck %s
+// CHECK: !DICallSiteParam(argno: 1, expr: !DIExpression())
+// CHECK-NEXT: !DICallSiteParam(argno: 2, expr: !DIExpression())
+// CHECK-NEXT: !DICallSiteParam(argno: 3, variable: !16, expr: !DIExpression(DW_OP_push_object_address))
+extern int foo(unsigned, unsigned, int *);
+#define NUMBER  17
+int global;
+void baa() {
+  int tmp;
+  global += foo(sizeof(tmp), sizeof(tmp), &tmp);
+  global += foo(NUMBER + 3 + sizeof(tmp), NUMBER + 0 * sizeof(tmp), &tmp);
+  global += foo(NUMBER + 3, NUMBER + 0 * sizeof(tmp), &tmp);
+}