[IR] Add emitters for DICallSite and DICallSiteParam metadata

[djtodoro]

Summary

Add methods that will be used for emitting DICallSite and DICallSiteParam metadata.

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

[aprantl]

Thanks! I'd like to have a discussion whether encoding this in IR and threading it through the compiler or performing an late MIR analysis is the better approach before reviewing the implementation in detail. We can either do this here or on llvm-dev.

bindings/go/llvm/dibuilder.go

func (d *DIBuilder) CreateAutoVariable(scope Metadata, v DIAutoVariable) Metadata {
   defer C.free(unsafe.Pointer(name))
   result := C.LLVMDIBuilderCreateAutoVariable(
     d.ref,
     scope.C,
     name, C.size_t(len(v.Name)),
     v.File.C,
     C.unsigned(v.Line),
     v.Type.C,
-    C.LLVMBool(boolToCInt(v.AlwaysPreserve)),
     C.LLVMDIFlags(v.Flags),
     C.uint32_t(v.AlignInBits),
   )
+
+  if C.LLVMBool(boolToCInt(v.AlwaysPreserve)) {
+    C.LLVMDIBuilderPreserveVariable(d.ref, scope.C, result.ref)
+  }
+
   return Metadata{C: result}
 }
 
 // DIParameterVariable holds the values for creating parameter variable debug metadata.
 type DIParameterVariable struct {
   Name           string
   File           Metadata
   Line           int
func (d *DIBuilder) CreateParameterVariable(scope Metadata, v DIParameterVariable) Metadata {
   result := C.LLVMDIBuilderCreateParameterVariable(
     d.ref,
     scope.C,
     name, C.size_t(len(v.Name)),
     C.unsigned(v.ArgNo),
     v.File.C,
     C.unsigned(v.Line),
     v.Type.C,
-    C.LLVMBool(boolToCInt(v.AlwaysPreserve)),
     C.LLVMDIFlags(v.Flags),
   )
+
+  if C.LLVMBool(boolToCInt(v.AlwaysPreserve)) {
+    C.LLVMDIBuilderPreserveVariable(d.ref, scope.C, result.ref)
+  }
+
   return Metadata{C: result}
 }
 
 // DIBasicType holds the values for creating basic type debug metadata.
 type DIBasicType struct {
   Name       string
   SizeInBits uint64
   Encoding   DwarfTypeEncoding

include/llvm-c/DebugInfo.h

 LLVMValueRef LLVMDIBuilderInsertDbgValueAtEnd(LLVMDIBuilderRef Builder,
                                               LLVMValueRef Val,
                                               LLVMMetadataRef VarInfo,
                                               LLVMMetadataRef Expr,
                                               LLVMMetadataRef DebugLoc,
                                               LLVMBasicBlockRef Block);
 
 /**
+ * Preserve a variable's debug info metadata in optimized code.
+ * \param Builder     The DIBuilder.
+ * \param Scope       The local scope the variable is declared in.
+ * \param DL          The variable's debug info descriptor.
+ */
+void LLVMDIBuilderPreserveVariable(LLVMDIBuilderRef Builder,
+                                   LLVMMetadataRef Scope,
+                                   LLVMMetadataRef DL);
+
+/**
  * Create a new descriptor for a local auto variable.
  * \param Builder         The DIBuilder.
  * \param Scope           The local scope the variable is declared in.
  * \param Name            Variable name.
  * \param NameLen         Length of variable name.
  * \param File            File where this variable is defined.
  * \param LineNo          Line number.
  * \param Ty              Metadata describing the type of the variable.
- * \param AlwaysPreserve  If true, this descriptor will survive optimizations.
  * \param Flags           Flags.
  * \param AlignInBits     Variable alignment.
  */
 LLVMMetadataRef LLVMDIBuilderCreateAutoVariable(
     LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
     size_t NameLen, LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty,
-    LLVMBool AlwaysPreserve, LLVMDIFlags Flags, uint32_t AlignInBits);
+    LLVMDIFlags Flags, uint32_t AlignInBits);
 
 /**
  * Create a new descriptor for a function parameter variable.
  * \param Builder         The DIBuilder.
  * \param Scope           The local scope the variable is declared in.
  * \param Name            Variable name.
  * \param NameLen         Length of variable name.
  * \param ArgNo           Unique argument number for this variable; starts at 1.
  * \param File            File where this variable is defined.
  * \param LineNo          Line number.
  * \param Ty              Metadata describing the type of the variable.
- * \param AlwaysPreserve  If true, this descriptor will survive optimizations.
  * \param Flags           Flags.
  */
 LLVMMetadataRef LLVMDIBuilderCreateParameterVariable(
     LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
     size_t NameLen, unsigned ArgNo, LLVMMetadataRef File, unsigned LineNo,
-    LLVMMetadataRef Ty, LLVMBool AlwaysPreserve, LLVMDIFlags Flags);
+    LLVMMetadataRef Ty, LLVMDIFlags Flags);
 
 /**
  * Get the metadata of the subprogram attached to a function.
  *
  * @see llvm::Function::getSubprogram()
  */
 LLVMMetadataRef LLVMGetSubprogram(LLVMValueRef Func);
 

include/llvm/IR/DIBuilder.h

class DIBuilder {
     SmallVector<TrackingMDNodeRef, 4> UnresolvedNodes;
     bool AllowUnresolvedNodes;
 
     /// Each subprogram's preserved local variables.
     ///
     /// Do not use a std::vector.  Some versions of libc++ apparently copy
     /// instead of move on grow operations, and TrackingMDRef is expensive to
     /// copy.
-    DenseMap<MDNode *, SmallVector<TrackingMDNodeRef, 1>> PreservedVariables;
+    DenseMap <MDNode *, SmallVector<TrackingMDNodeRef, 1>> PreservedVariables;
 
+    /// Key of the map represents variable's declaration pointer. Value of the
+    /// map represent pair of variable's ID in second operand's function's scope
+    /// presreved variables.
+    /// Such pair tracking is needed bacause CXXOperatorCallExpr can refer
+    /// outer scope's variable by refrence.
+    using VarDecl = const void*;
+    using VarIDScopePair = std::pair<uint64_t, DISubprogram *>;
+    using VarDeclIDMap = DenseMap <VarDecl, VarIDScopePair>;
+    VarDeclIDMap VarDeclIDs;
+
+    /// Each subprogram's preserved call sites.
+    DenseMap<MDNode *, SmallVector<TrackingMDNodeRef, 1>> PreservedCallSites;
+
     /// Each subprogram's preserved labels.
     DenseMap<MDNode *, SmallVector<TrackingMDNodeRef, 1>> PreservedLabels;
 
     /// Create a temporary.
     ///
     /// Create an \a temporary node and track it in \a UnresolvedNodes.
     void trackIfUnresolved(MDNode *N);
 
public:
 
     /// Identical to createGlobalVariable
     /// except that the resulting DbgNode is temporary and meant to be RAUWed.
     DIGlobalVariable *createTempGlobalVariableFwdDecl(
         DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *File,
         unsigned LineNo, DIType *Ty, bool isLocalToUnit, MDNode *Decl = nullptr,
         MDTuple *templateParams = nullptr, uint32_t AlignInBits = 0);
 
+    /// Save variable in container that keeps all variable's debug information.
+    /// \param Scope     Variable scope that is used to get function scope.
+    /// \param DL        Debug information for variable
+    /// \param VD        Variable declaration pointer. This param is used for
+    ///                  faster search for certain variable.
+    void preserveVariable(const DIScope *Scope, DILocalVariable *DL,
+                          VarDecl VD = nullptr);
+
+    /// Find debug info for given variable declaration with specific function
+    /// scope.
+    /// \param Scope     Scope that is used to determine function scope of
+    ///                  searched variable.
+    /// \param VD        Address of searched variable's declaration.
+    DILocalVariable* getVariableLocation(const DIScope *Scope, VarDecl VD);
+
+
     /// Create a new descriptor for an auto variable.  This is a local variable
     /// that is not a subprogram parameter.
     ///
     /// \c Scope must be a \a DILocalScope, and thus its scope chain eventually
     /// leads to a \a DISubprogram.
     ///
     /// If \c AlwaysPreserve, this variable will be referenced from its
     /// containing subprogram, and will survive some optimizations.
     DILocalVariable *
     createAutoVariable(DIScope *Scope, StringRef Name, DIFile *File,
-                       unsigned LineNo, DIType *Ty, bool AlwaysPreserve = false,
+                       unsigned LineNo, DIType *Ty,
                        DINode::DIFlags Flags = DINode::FlagZero,
                        uint32_t AlignInBits = 0);
 
     /// Create a new descriptor for an label.
     ///
     /// \c Scope must be a \a DILocalScope, and thus its scope chain eventually
     /// leads to a \a DISubprogram.
     DILabel *
public:
     /// subprogram parameters.  \c ArgNo should not conflict with other
     /// parameters of the same subprogram.
     ///
     /// If \c AlwaysPreserve, this variable will be referenced from its
     /// containing subprogram, and will survive some optimizations.
     DILocalVariable *
     createParameterVariable(DIScope *Scope, StringRef Name, unsigned ArgNo,
                             DIFile *File, unsigned LineNo, DIType *Ty,
-                            bool AlwaysPreserve = false,
                             DINode::DIFlags Flags = DINode::FlagZero);
 
     /// Create a new descriptor for the specified
     /// variable which has a complex address expression for its address.
     /// \param Addr        An array of complex address operations.
     DIExpression *createExpression(ArrayRef<uint64_t> Addr = None);
     DIExpression *createExpression(ArrayRef<int64_t> Addr);
 
public:
     /// \param ThrownTypes   Exception types this function may throw.
     DISubprogram *
     createFunction(DIScope *Scope, StringRef Name, StringRef LinkageName,
                    DIFile *File, unsigned LineNo, DISubroutineType *Ty,
                    unsigned ScopeLine, DINode::DIFlags Flags = DINode::FlagZero,
                    DISubprogram::DISPFlags SPFlags = DISubprogram::SPFlagZero,
                    DITemplateParameterArray TParams = nullptr,
                    DISubprogram *Decl = nullptr,
-                   DITypeArray ThrownTypes = nullptr);
+                   DITypeArray ThrownTypes = nullptr,
+                   bool isDeclForCallSite = false);
 
     /// Identical to createFunction,
     /// except that the resulting DbgNode is meant to be RAUWed.
     DISubprogram *createTempFunctionFwdDecl(
         DIScope *Scope, StringRef Name, StringRef LinkageName, DIFile *File,
         unsigned LineNo, DISubroutineType *Ty, unsigned ScopeLine,
         DINode::DIFlags Flags = DINode::FlagZero,
         DISubprogram::DISPFlags SPFlags = DISubprogram::SPFlagZero,
createMethod(DIScope *Scope, StringRef Name, StringRef LinkageName,
                  DIFile *File, unsigned LineNo, DISubroutineType *Ty,
                  unsigned VTableIndex = 0, int ThisAdjustment = 0,
                  DIType *VTableHolder = nullptr,
                  DINode::DIFlags Flags = DINode::FlagZero,
                  DISubprogram::DISPFlags SPFlags = DISubprogram::SPFlagZero,
                  DITemplateParameterArray TParams = nullptr,
                  DITypeArray ThrownTypes = nullptr);
 
+    /// Creates a descriptor for a call site with the
+    /// specified context.
+    /// \param Scope             Scope of called function.
+    /// \param Line              Line of called function.
+    /// \param CalledSubprogram  Called function metadata.
+    /// \param Params            Array of DICallSiteParam that describe
+    ///                          function arguments.
+    DICallSite *createCallSite(DIScope *Scope, DIFile *File,
+                               unsigned Line,
+                               DISubprogram* CalledSubprogram,
+                               DINodeArray Params,
+                               bool AlwaysPreserve = false);
+
+    /// Creates new call site function parameter. It can only describe simple
+    /// parameters that consists only of variable and some constant. It is not
+    /// meant to describe parameter that is evaluated by another function
+    /// call. If argument is constant value only third parameter that describes
+    /// it is provided.
+    /// \param ArgNo       Order number of argument that new call site param
+    ///                    will describe.
+    /// \param DIExpr      Expression over the passed variable. If no variable
+    ///                    is passed then it is expression for constant value.
+    /// \param Scope       A variables scope that is used to get function
+    ///                    scope.
+    /// \param VD          A variable declaration pointer trough which is
+    ///                    argument passed.
+    DICallSiteParam * createCallSiteParam(unsigned ArgNo,
+                                          DIExpression *DIExpr,
+                                          DIScope *Scope = nullptr,
+                                          VarDecl VD = nullptr);
+
     /// 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/LLVMContext.h

enum : unsigned {
     MD_type = 19,                     // "type"
     MD_section_prefix = 20,           // "section_prefix"
     MD_absolute_symbol = 21,          // "absolute_symbol"
     MD_associated = 22,               // "associated"
     MD_callees = 23,                  // "callees"
     MD_irr_loop = 24,                 // "irr_loop"
     MD_access_group = 25,             // "llvm.access.group"
     MD_callback = 26,                 // "callback"
+    MD_call_site = 27,                // "call_site"
   };
 
   /// Known operand bundle tag IDs, which always have the same value.  All
   /// operand bundle tags that LLVM has special knowledge of are listed here.
   /// Additionally, this scheme allows LLVM to efficiently check for specific
   /// operand bundle tags without comparing strings.
   enum : unsigned {
     OB_deopt = 0,         // "deopt"

lib/IR/DIBuilder.cpp

if (!Temp || !Temp->isTemporary())
     return;
 
   SmallVector<Metadata *, 16> RetainedNodes;
 
   auto PV = PreservedVariables.find(SP);
   if (PV != PreservedVariables.end())
     RetainedNodes.append(PV->second.begin(), PV->second.end());
 
+  auto PCS = PreservedCallSites.find(SP);
+  if (PCS != PreservedCallSites.end()) {
+    SP->setIsDesribedByCallSites();
+    RetainedNodes.append(PCS->second.begin(), PCS->second.end());
+  }
+
   auto PL = PreservedLabels.find(SP);
   if (PL != PreservedLabels.end())
     RetainedNodes.append(PL->second.begin(), PL->second.end());
 
   DINodeArray Node = getOrCreateArray(RetainedNodes);
 
   TempMDTuple(Temp)->replaceAllUsesWith(Node.get());
 }
DIGlobalVariable *DIBuilder::createTempGlobalVariableFwdDecl(
 
   return DIGlobalVariable::getTemporary(
              VMContext, cast_or_null<DIScope>(Context), Name, LinkageName, F,
              LineNumber, Ty, isLocalToUnit, false,
              cast_or_null<DIDerivedType>(Decl), templateParams, AlignInBits)
       .release();
 }
 
+DILocalVariable *DIBuilder::getVariableLocation(const DIScope *Scope,
+                                                VarDecl VD) {
+  DISubprogram *Fn = getDISubprogram(Scope);
+  assert(Fn && "Missing subprogram for local variable");
+  VarIDScopePair VarIDScope = VarDeclIDs[VD];
+  if (VarIDScope.second == Fn)
+    return dyn_cast<DILocalVariable>(PreservedVariables[Fn][VarIDScope.first]);
+  return nullptr;
+}
+
+/// The optimizer may remove local variables. If there is an interest
+/// to preserve variable info in such situation then stash it in a
+/// named mdnode.
+void DIBuilder::preserveVariable(const DIScope *Scope, DILocalVariable *DL,
+                                 VarDecl VD) {
+  DISubprogram *Fn = getDISubprogram(Scope);
+  assert(Fn && "Missing subprogram for local variable");
+
+  // Variables that don't have declaration.
+  if (!VD) {
+    PreservedVariables[Fn].emplace_back(DL);
+  } else {
+    VarIDScopePair &IDScope = VarDeclIDs[VD];
+    if (!IDScope.first) {
+      PreservedVariables[Fn].emplace_back(DL);
+      IDScope.first = PreservedVariables[Fn].size() - 1;
+      IDScope.second = Fn;
+    }
+  }
+}
+
 static DILocalVariable *createLocalVariable(
     LLVMContext &VMContext,
-    DenseMap<MDNode *, SmallVector<TrackingMDNodeRef, 1>> &PreservedVariables,
     DIScope *Scope, StringRef Name, unsigned ArgNo, DIFile *File,
-    unsigned LineNo, DIType *Ty, bool AlwaysPreserve, DINode::DIFlags Flags,
+    unsigned LineNo, DIType *Ty, DINode::DIFlags Flags,
     uint32_t AlignInBits) {
   // FIXME: Why getNonCompileUnitScope()?
   // FIXME: Why is "!Context" okay here?
   // FIXME: Why doesn't this check for a subprogram or lexical block (AFAICT
   // the only valid scopes)?
   DIScope *Context = getNonCompileUnitScope(Scope);
 
-  auto *Node =
-      DILocalVariable::get(VMContext, cast_or_null<DILocalScope>(Context), Name,
-                           File, LineNo, Ty, ArgNo, Flags, AlignInBits);
-  if (AlwaysPreserve) {
-    // The optimizer may remove local variables. If there is an interest
-    // to preserve variable info in such situation then stash it in a
-    // named mdnode.
-    DISubprogram *Fn = getDISubprogram(Scope);
-    assert(Fn && "Missing subprogram for local variable");
-    PreservedVariables[Fn].emplace_back(Node);
-  }
-  return Node;
+  return DILocalVariable::get(VMContext, cast_or_null<DILocalScope>(Context),
+                              Name, File, LineNo, Ty, ArgNo, Flags,
+                              AlignInBits);
 }
 
 DILocalVariable *DIBuilder::createAutoVariable(DIScope *Scope, StringRef Name,
                                                DIFile *File, unsigned LineNo,
-                                               DIType *Ty, bool AlwaysPreserve,
+                                               DIType *Ty,
                                                DINode::DIFlags Flags,
                                                uint32_t AlignInBits) {
-  return createLocalVariable(VMContext, PreservedVariables, Scope, Name,
-                             /* ArgNo */ 0, File, LineNo, Ty, AlwaysPreserve,
+  return createLocalVariable(VMContext, Scope, Name,
+                             /* ArgNo */ 0, File, LineNo, Ty,
                              Flags, AlignInBits);
 }
 
 DILocalVariable *DIBuilder::createParameterVariable(
     DIScope *Scope, StringRef Name, unsigned ArgNo, DIFile *File,
-    unsigned LineNo, DIType *Ty, bool AlwaysPreserve, DINode::DIFlags Flags) {
+    unsigned LineNo, DIType *Ty, DINode::DIFlags Flags) {
   assert(ArgNo && "Expected non-zero argument number for parameter");
-  return createLocalVariable(VMContext, PreservedVariables, Scope, Name, ArgNo,
-                             File, LineNo, Ty, AlwaysPreserve, Flags,
+  return createLocalVariable(VMContext, Scope, Name, ArgNo,
+                             File, LineNo, Ty, Flags,
                              /* AlignInBits */0);
 }
 
 DILabel *DIBuilder::createLabel(
     DIScope *Scope, StringRef Name, DIFile *File,
     unsigned LineNo, bool AlwaysPreserve) {
   DIScope *Context = getNonCompileUnitScope(Scope);
 
static DISubprogram *getSubprogram(bool IsDistinct, Ts &&... Args) {
   return DISubprogram::get(std::forward<Ts>(Args)...);
 }
 
 DISubprogram *DIBuilder::createFunction(
     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) {
+    DITypeArray ThrownTypes, bool isDeclForCallSite) {
   bool IsDefinition = SPFlags & DISubprogram::SPFlagDefinition;
   auto *Node = getSubprogram(
       /*IsDistinct=*/IsDefinition, VMContext, getNonCompileUnitScope(Context),
       Name, LinkageName, File, LineNo, Ty, ScopeLine, nullptr, 0, 0, Flags,
       SPFlags, IsDefinition ? CUNode : nullptr, TParams, Decl,
       MDTuple::getTemporary(VMContext, None).release(), ThrownTypes);
 
-  if (IsDefinition)
+  if (isDeclForCallSite)
+    Node->setIsDeclForCallSite();
+  if (IsDefinition || isDeclForCallSite)
     AllSubprograms.push_back(Node);
   trackIfUnresolved(Node);
   return Node;
 }
 
+DICallSite *DIBuilder::createCallSite(DIScope *Scope, DIFile *File,
+                                      unsigned Line,
+                                      DISubprogram *CalledSubprogram,
+                                      DINodeArray Params, bool AlwaysPreserve) {
+  DIScope *Context = getNonCompileUnitScope(Scope);
+  auto *Node = DICallSite::get(VMContext, cast_or_null<DILocalScope>(Context),
+                               File, Params, Line, CalledSubprogram);
+  if (AlwaysPreserve) {
+    // The optimizer may remove callsite. If there is an interest
+    // to preserve callsite info in such situation then append it to
+    // the list of retained nodes of the DISubprogram.
+    DISubprogram *Fn = getDISubprogram(Scope);
+    assert(Fn && "Missing subprogram for callsite");
+    PreservedCallSites[Fn].emplace_back(Node);
+  }
+
+  return Node;
+}
+
+DICallSiteParam *DIBuilder::createCallSiteParam(unsigned ArgNo,
+                                                DIExpression *Expr,
+                                                DIScope *Scope, VarDecl VD) {
+  if (VD != nullptr) {
+    DILocalVariable *DILV = getVariableLocation(Scope, VD);
+    // If we can't find DILocalVariable for variable declaration, currently
+    // we can't find it for global variables (including functions), we will
+    // emit simple call site with empty expression and leave space for other
+    // approach to find expression for this call site parameter.
+    if (!DILV)
+      Expr = DIExpression::get(VMContext, {});
+    else
+      return DICallSiteParam::get(VMContext, ArgNo, DILV, Expr);
+  }
+  return DICallSiteParam::get(VMContext, ArgNo, Expr);
+}
+
 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/DebugInfo.cpp

LLVMValueRef LLVMDIBuilderInsertDbgValueAtEnd(LLVMDIBuilderRef Builder,
                                               LLVMMetadataRef DebugLoc,
                                               LLVMBasicBlockRef Block) {
   return wrap(unwrap(Builder)->insertDbgValueIntrinsic(
                   unwrap(Val), unwrap<DILocalVariable>(VarInfo),
                   unwrap<DIExpression>(Expr), unwrap<DILocation>(DebugLoc),
                   unwrap(Block)));
 }
 
+void LLVMDIBuilderPreserveVariable(LLVMDIBuilderRef Builder,
+                                   LLVMMetadataRef Scope,
+                                   LLVMMetadataRef DL) {
+  unwrap(Builder)->preserveVariable(unwrap<DIScope>(Scope),
+                                    unwrap<DILocalVariable>(DL));
+}
+
 LLVMMetadataRef LLVMDIBuilderCreateAutoVariable(
     LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
     size_t NameLen, LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty,
-    LLVMBool AlwaysPreserve, LLVMDIFlags Flags, uint32_t AlignInBits) {
+    LLVMDIFlags Flags, uint32_t AlignInBits) {
   return wrap(unwrap(Builder)->createAutoVariable(
                   unwrap<DIScope>(Scope), {Name, NameLen}, unwrap<DIFile>(File),
-                  LineNo, unwrap<DIType>(Ty), AlwaysPreserve,
+                  LineNo, unwrap<DIType>(Ty),
                   map_from_llvmDIFlags(Flags), AlignInBits));
 }
 
 LLVMMetadataRef LLVMDIBuilderCreateParameterVariable(
     LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
     size_t NameLen, unsigned ArgNo, LLVMMetadataRef File, unsigned LineNo,
-    LLVMMetadataRef Ty, LLVMBool AlwaysPreserve, LLVMDIFlags Flags) {
+    LLVMMetadataRef Ty, LLVMDIFlags Flags) {
   return wrap(unwrap(Builder)->createParameterVariable(
                   unwrap<DIScope>(Scope), {Name, NameLen}, ArgNo, unwrap<DIFile>(File),
-                  LineNo, unwrap<DIType>(Ty), AlwaysPreserve,
+                  LineNo, unwrap<DIType>(Ty),
                   map_from_llvmDIFlags(Flags)));
 }
 
 LLVMMetadataRef LLVMDIBuilderGetOrCreateSubrange(LLVMDIBuilderRef Builder,
                                                  int64_t Lo, int64_t Count) {
   return wrap(unwrap(Builder)->getOrCreateSubrange(Lo, Count));
 }
 

lib/IR/DebugInfoMetadata.cpp

 }
 
 bool DIExpression::isValid() const {
   for (auto I = expr_op_begin(), E = expr_op_end(); I != E; ++I) {
     // Check that there's space for the operand.
     if (I->get() + I->getSize() > E->get())
       return false;
 
+    uint64_t Op = I->getOp();
+    if (Op >= dwarf::DW_OP_lit0 && Op <= dwarf::DW_OP_lit31)
+      continue;
     // Check that the operand is valid.
-    switch (I->getOp()) {
+    switch (Op) {
     default:
       return false;
     case dwarf::DW_OP_LLVM_fragment:
       // A fragment operator must appear at the end.
       return I->get() + I->getSize() == E->get();
     case dwarf::DW_OP_stack_value: {
       // Must be the last one or followed by a DW_OP_LLVM_fragment.
       if (I->get() + I->getSize() == E->get())
case dwarf::DW_OP_swap: {
       // DW_LLVM_OP_implicit_location as a placeholder for the location this
       // DIExpression is attached to, or else pass the number of implicit stack
       // elements into isValid.
       if (getNumElements() == 1)
         return false;
       break;
     }
     case dwarf::DW_OP_constu:
+    case dwarf::DW_OP_consts:
     case dwarf::DW_OP_plus_uconst:
     case dwarf::DW_OP_plus:
     case dwarf::DW_OP_minus:
     case dwarf::DW_OP_mul:
     case dwarf::DW_OP_div:
     case dwarf::DW_OP_mod:
     case dwarf::DW_OP_or:
     case dwarf::DW_OP_and:
     case dwarf::DW_OP_xor:
     case dwarf::DW_OP_shl:
     case dwarf::DW_OP_shr:
     case dwarf::DW_OP_shra:
     case dwarf::DW_OP_deref:
     case dwarf::DW_OP_xderef:
-    case dwarf::DW_OP_lit0:
+    case dwarf::DW_OP_neg:
+    case dwarf::DW_OP_push_object_address:
     case dwarf::DW_OP_not:
     case dwarf::DW_OP_dup:
       break;
     }
   }
   return true;
 }
 

lib/IR/LLVMContext.cpp

std::pair<unsigned, StringRef> MDKinds[] = {
     {MD_type, "type"},
     {MD_section_prefix, "section_prefix"},
     {MD_absolute_symbol, "absolute_symbol"},
     {MD_associated, "associated"},
     {MD_callees, "callees"},
     {MD_irr_loop, "irr_loop"},
     {MD_access_group, "llvm.access.group"},
     {MD_callback, "callback"},
+    {MD_call_site, "call_site"},
   };
 
   for (auto &MDKind : MDKinds) {
     unsigned ID = getMDKindID(MDKind.second);
     assert(ID == MDKind.first && "metadata kind id drifted");
     (void)ID;
   }
 

lib/IR/Verifier.cpp

if (auto *Params = N.getRawTemplateParams())
     visitTemplateParams(N, *Params);
   if (auto *S = N.getRawDeclaration())
     AssertDI(isa<DISubprogram>(S) && !cast<DISubprogram>(S)->isDefinition(),
              "invalid subprogram declaration", &N, S);
   if (auto *RawNode = N.getRawRetainedNodes()) {
     auto *Node = dyn_cast<MDTuple>(RawNode);
     AssertDI(Node, "invalid retained nodes list", &N, RawNode);
     for (Metadata *Op : Node->operands()) {
-      AssertDI(Op && (isa<DILocalVariable>(Op) || isa<DILabel>(Op)),
-               "invalid retained nodes, expected DILocalVariable or DILabel",
+      AssertDI(Op && (isa<DILocalVariable>(Op) || isa<DILabel>(Op) ||
+                      isa<DICallSite>(Op)),
+               "invalid retained nodes, expected DILocalVariable or DILabel"
+               " or DICallSite",
                &N, Node, Op);
     }
   }
   AssertDI(!hasConflictingReferenceFlags(N.getFlags()),
            "invalid reference flags", &N);
 
   auto *Unit = N.getRawUnit();
   if (N.isDefinition()) {

test/ThinLTO/X86/lazyload_metadata.ll

 ; Do setup work for all below tests: generate bitcode and combined index
 ; RUN: opt -module-summary %s -o %t.bc -bitcode-mdindex-threshold=0
 ; RUN: opt -module-summary %p/Inputs/lazyload_metadata.ll -o %t2.bc -bitcode-mdindex-threshold=0
 ; RUN: llvm-lto -thinlto-action=thinlink -o %t3.bc %t.bc %t2.bc
 ; REQUIRES: asserts
 
 ; Check that importing @globalfunc1 does not trigger loading all the global
 ; metadata for @globalfunc2 and @globalfunc3
 
 ; RUN: llvm-lto -thinlto-action=import %t2.bc -thinlto-index=%t3.bc \
 ; RUN:          -o /dev/null -stats \
 ; RUN:  2>&1 | FileCheck %s -check-prefix=LAZY
-; LAZY: 59 bitcode-reader  - Number of Metadata records loaded
+; LAZY: 61 bitcode-reader  - Number of Metadata records loaded
 ; LAZY: 2 bitcode-reader  - Number of MDStrings loaded
 
 ; RUN: llvm-lto -thinlto-action=import %t2.bc -thinlto-index=%t3.bc \
 ; RUN:          -o /dev/null -disable-ondemand-mds-loading -stats \
 ; RUN:  2>&1 | FileCheck %s -check-prefix=NOTLAZY
-; NOTLAZY: 68 bitcode-reader  - Number of Metadata records loaded
+; NOTLAZY: 70 bitcode-reader  - Number of Metadata records loaded
 ; NOTLAZY: 7 bitcode-reader  - Number of MDStrings loaded
 
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.11.0"
 
 define void @globalfunc1(i32 %arg) {
   %x = call i1 @llvm.type.test(i8* undef, metadata !"typeid1")

tools/llvm-c-test/debuginfo.c

LLVMDIBuilderCreateFunction(DIB, File, "foo", 3, "foo", 3,
                                 File, 42, FunctionTy, true, true,
                                 42, 0, false);
   LLVMMetadataReplaceAllUsesWith(ReplaceableFunctionMetadata, FunctionMetadata);
 
   LLVMMetadataRef FooParamExpression =
     LLVMDIBuilderCreateExpression(DIB, NULL, 0);
   LLVMMetadataRef FooParamVar1 =
     LLVMDIBuilderCreateParameterVariable(DIB, FunctionMetadata, "a", 1, 1, File,
-                                         42, Int64Ty, true, 0);
+                                         42, Int64Ty, 0);
+  LLVMDIBuilderPreserveVariable(DIB, FunctionMetadata, FooParamVar1);
   LLVMDIBuilderInsertDeclareAtEnd(DIB, LLVMConstInt(LLVMInt64Type(), 0, false),
                                   FooParamVar1, FooParamExpression,
                                   FooParamLocation, FooEntryBlock);
   LLVMMetadataRef FooParamVar2 =
     LLVMDIBuilderCreateParameterVariable(DIB, FunctionMetadata, "b", 1, 2, File,
-                                         42, Int64Ty, true, 0);
+                                         42, Int64Ty, 0);
+  LLVMDIBuilderPreserveVariable(DIB, FunctionMetadata, FooParamVar2);
   LLVMDIBuilderInsertDeclareAtEnd(DIB, LLVMConstInt(LLVMInt64Type(), 0, false),
                                   FooParamVar2, FooParamExpression,
                                   FooParamLocation, FooEntryBlock);
   LLVMMetadataRef FooParamVar3 =
     LLVMDIBuilderCreateParameterVariable(DIB, FunctionMetadata, "c", 1, 3, File,
-                                         42, VectorTy, true, 0);
+                                         42, VectorTy, 0);
+  LLVMDIBuilderPreserveVariable(DIB, FunctionMetadata, FooParamVar3);
   LLVMDIBuilderInsertDeclareAtEnd(DIB, LLVMConstInt(LLVMInt64Type(), 0, false),
                                   FooParamVar3, FooParamExpression,
                                   FooParamLocation, FooEntryBlock);
 
   LLVMSetSubprogram(FooFunction, FunctionMetadata);
 
   LLVMMetadataRef FooLexicalBlock =
     LLVMDIBuilderCreateLexicalBlock(DIB, FunctionMetadata, File, 42, 0);
 
   LLVMBasicBlockRef FooVarBlock = LLVMAppendBasicBlock(FooFunction, "vars");
   LLVMMetadataRef FooVarsLocation =
     LLVMDIBuilderCreateDebugLocation(LLVMGetGlobalContext(), 43, 0,
                                      FunctionMetadata, NULL);
   LLVMMetadataRef FooVar1 =
     LLVMDIBuilderCreateAutoVariable(DIB, FooLexicalBlock, "d", 1, File,
-                                    43, Int64Ty, true, 0, 0);
+                                    43, Int64Ty, 0, 0);
+  LLVMDIBuilderPreserveVariable(DIB, FunctionMetadata, FooVar1);
   LLVMValueRef FooVal1 = LLVMConstInt(LLVMInt64Type(), 0, false);
   LLVMMetadataRef FooVarValueExpr =
     LLVMDIBuilderCreateConstantValueExpression(DIB, 0);
 
   LLVMDIBuilderInsertDbgValueAtEnd(DIB, FooVal1, FooVar1, FooVarValueExpr,
                                    FooVarsLocation, FooVarBlock);
 
   LLVMDIBuilderFinalize(DIB);

tools/opt/Debugify.cpp

for (BasicBlock &BB : F) {
         // Phis and EH pads must be grouped at the beginning of the block.
         // Only advance the insertion point when we finish visiting these.
         if (!isa<PHINode>(I) && !I->isEHPad())
           InsertBefore = I->getNextNode();
 
         std::string Name = utostr(NextVar++);
         const DILocation *Loc = I->getDebugLoc().get();
         auto LocalVar = DIB.createAutoVariable(SP, Name, File, Loc->getLine(),
-                                               getCachedDIType(I->getType()),
-                                               /*AlwaysPreserve=*/true);
+                                               getCachedDIType(I->getType()));
+        DIB.preserveVariable(Loc->getScope(), LocalVar);
         DIB.insertDbgValueIntrinsic(I, LocalVar, DIB.createExpression(), Loc,
                                     InsertBefore);
       }
     }
     DIB.finalizeSubprogram(SP);
   }
   DIB.finalize();
 

unittests/Transforms/Utils/CloningTest.cpp

void CreateOldFunctionBodyAndDI() {
     Value* AllocaContent = IBuilder.getInt32(1);
     Instruction* Store = IBuilder.CreateStore(AllocaContent, Alloca);
     IBuilder.SetCurrentDebugLocation(DebugLoc::get(5, 2, Subprogram));
 
     // Create a local variable around the alloca
     auto *IntType = DBuilder.createBasicType("int", 32, dwarf::DW_ATE_signed);
     auto *E = DBuilder.createExpression();
     auto *Variable =
-        DBuilder.createAutoVariable(Subprogram, "x", File, 5, IntType, true);
+        DBuilder.createAutoVariable(Subprogram, "x", File, 5, IntType);
+    DBuilder.preserveVariable(cast<DIScope>(Loc->getScope()), Variable);
     auto *DL = DILocation::get(Subprogram->getContext(), 5, 0, Subprogram);
     DBuilder.insertDeclare(Alloca, Variable, E, DL, Store);
     DBuilder.insertDbgValueIntrinsic(AllocaContent, Variable, E, DL, Entry);
     // Also create an inlined variable.
     // Create a distinct struct type that we should not duplicate during
     // cloning).
     auto *StructType = DICompositeType::getDistinct(
         C, dwarf::DW_TAG_structure_type, "some_struct", nullptr, 0, nullptr,
         nullptr, 32, 32, 0, DINode::FlagZero, nullptr, 0, nullptr, nullptr);
     auto *InlinedSP = DBuilder.createFunction(
         CU, "inlined", "inlined", File, 8, FuncType, 9, DINode::FlagZero,
         DISubprogram::SPFlagLocalToUnit | DISubprogram::SPFlagDefinition);
     auto *InlinedVar =
-        DBuilder.createAutoVariable(InlinedSP, "inlined", File, 5, StructType, true);
+        DBuilder.createAutoVariable(InlinedSP, "inlined", File, 5, StructType);
+    DBuilder.preserveVariable(cast<DIScope>(InlinedSP), InlinedVar);
     auto *Scope = DBuilder.createLexicalBlock(
         DBuilder.createLexicalBlockFile(InlinedSP, File), File, 1, 1);
     auto InlinedDL =
         DebugLoc::get(9, 4, Scope, DebugLoc::get(5, 2, Subprogram));
     IBuilder.SetCurrentDebugLocation(InlinedDL);
     DBuilder.insertDeclare(Alloca, InlinedVar, E, InlinedDL, Store);
     IBuilder.CreateStore(IBuilder.getInt32(2), Alloca);
     // Finalize the debug info.