[IR] Add DICallSiteParam and new params field to DILocation

[milica-lazarevic]

Summary

New kind of MDNode - DICallSiteParam has been added. DICallSiteParam should describe function arguments at call site, whenever it's posible. It coresponds to DWARF tag DW_TAG_call_site_parameter.

New params field has been added to DILocation type. Params field represents an array of DICallSiteParam elements. It should be attached to call instructions and describe values that has being passed to function. Later in pipeline, we're trying to interpret those caller site values as DWARF tag DW_TAG_call_site_parameter.

[aprantl]

Mechanically this looks fine. You will need to add some assembler round-trip test cases to llvm/test/Assembler. Can you explain what feature this is going to enable and in which pass you are intending to produce the new DINode?

llvm/include/llvm-c/DebugInfo.h

enum {
   LLVMDINamespaceMetadataKind,
   LLVMDIModuleMetadataKind,
   LLVMDITemplateTypeParameterMetadataKind,
   LLVMDITemplateValueParameterMetadataKind,
   LLVMDIGlobalVariableMetadataKind,
   LLVMDILocalVariableMetadataKind,
   LLVMDILabelMetadataKind,
   LLVMDIObjCPropertyMetadataKind,
+  LLVMDICallSiteParamMetadataKind,
   LLVMDIImportedEntityMetadataKind,
   LLVMDIMacroMetadataKind,
   LLVMDIMacroFileMetadataKind,
   LLVMDICommonBlockMetadataKind,
   LLVMDIStringTypeMetadataKind,
   LLVMDIGenericSubrangeMetadataKind,
   LLVMDIArgListMetadataKind
 };

llvm/include/llvm/Bitcode/LLVMBitCodes.h

enum MetadataCodes {
   METADATA_INDEX_OFFSET = 38,           // [offset]
   METADATA_INDEX = 39,                  // [bitpos]
   METADATA_LABEL = 40,                  // [distinct, scope, name, file, line]
   METADATA_STRING_TYPE = 41,            // [distinct, name, size, align,...]
   // Codes 42 and 43 are reserved for support for Fortran array specific debug
   // info.
   METADATA_COMMON_BLOCK = 44,     // [distinct, scope, name, variable,...]
   METADATA_GENERIC_SUBRANGE = 45, // [distinct, count, lo, up, stride]
-  METADATA_ARG_LIST = 46          // [n x [type num, value num]]
+  METADATA_ARG_LIST = 46,         // [n x [type num, value num]]
+  METADATA_CALL_SITE_PARAM = 47   // [distinct, argnum, expr]
 };
 
 // The constants block (CONSTANTS_BLOCK_ID) describes emission for each
 // constant and maintains an implicit current type value.
 enum ConstantsCodes {
   CST_CODE_SETTYPE = 1,          // SETTYPE:       [typeid]
   CST_CODE_NULL = 2,             // NULL
   CST_CODE_UNDEF = 3,            // UNDEF

llvm/include/llvm/IR/DebugInfoMetadata.h

static bool classof(const Metadata *MD) {
     case DINamespaceKind:
     case DICommonBlockKind:
     case DITemplateTypeParameterKind:
     case DITemplateValueParameterKind:
     case DIGlobalVariableKind:
     case DILocalVariableKind:
     case DILabelKind:
     case DIObjCPropertyKind:
+    case DICallSiteParamKind:
     case DIImportedEntityKind:
     case DIModuleKind:
     case DIGenericSubrangeKind:
       return true;
     }
   }
 };
 
class DILocation : public MDNode {
 
   DILocation(LLVMContext &C, StorageType Storage, unsigned Line,
              unsigned Column, ArrayRef<Metadata *> MDs, bool ImplicitCode);
   ~DILocation() { dropAllReferences(); }
 
   static DILocation *getImpl(LLVMContext &Context, unsigned Line,
                              unsigned Column, Metadata *Scope,
                              Metadata *InlinedAt, bool ImplicitCode,
-                             StorageType Storage, bool ShouldCreate = true);
+                             Metadata *Parameters, StorageType Storage,
+                             bool ShouldCreate = true);
   static DILocation *getImpl(LLVMContext &Context, unsigned Line,
                              unsigned Column, DILocalScope *Scope,
                              DILocation *InlinedAt, bool ImplicitCode,
-                             StorageType Storage, bool ShouldCreate = true) {
+                             DINodeArray Parameters, StorageType Storage,
+                             bool ShouldCreate = true) {
     return getImpl(Context, Line, Column, static_cast<Metadata *>(Scope),
-                   static_cast<Metadata *>(InlinedAt), ImplicitCode, Storage,
-                   ShouldCreate);
+                   static_cast<Metadata *>(InlinedAt), ImplicitCode,
+                   Parameters.get(), Storage, ShouldCreate);
   }
 
   TempDILocation cloneImpl() const {
     // Get the raw scope/inlinedAt since it is possible to invoke this on
     // a DILocation containing temporary metadata.
     return getTemporary(getContext(), getLine(), getColumn(), getRawScope(),
-                        getRawInlinedAt(), isImplicitCode());
+                        getRawInlinedAt(), isImplicitCode(),
+                        getRawParameters());
   }
 
 public:
   // Disallow replacing operands.
   void replaceOperandWith(unsigned I, Metadata *New) = delete;
 
   DEFINE_MDNODE_GET(DILocation,
                     (unsigned Line, unsigned Column, Metadata *Scope,
-                     Metadata *InlinedAt = nullptr, bool ImplicitCode = false),
-                    (Line, Column, Scope, InlinedAt, ImplicitCode))
+                     Metadata *InlinedAt = nullptr, bool ImplicitCode = false,
+                     Metadata *Parameters = nullptr),
+                    (Line, Column, Scope, InlinedAt, ImplicitCode, Parameters))
   DEFINE_MDNODE_GET(DILocation,
                     (unsigned Line, unsigned Column, DILocalScope *Scope,
-                     DILocation *InlinedAt = nullptr,
-                     bool ImplicitCode = false),
-                    (Line, Column, Scope, InlinedAt, ImplicitCode))
+                     DILocation *InlinedAt = nullptr, bool ImplicitCode = false,
+                     DINodeArray Parameters = nullptr),
+                    (Line, Column, Scope, InlinedAt, ImplicitCode, Parameters))
 
   /// Return a (temporary) clone of this.
   TempDILocation clone() const { return cloneImpl(); }
 
   unsigned getLine() const { return SubclassData32; }
   unsigned getColumn() const { return SubclassData16; }
   DILocalScope *getScope() const { return cast<DILocalScope>(getRawScope()); }
 
   DILocation *getInlinedAt() const {
     return cast_or_null<DILocation>(getRawInlinedAt());
   }
 
+  DINodeArray getParameters() const {
+    return cast_or_null<MDTuple>(getRawParameters());
+  }
+
   /// Check if the location corresponds to an implicit code.
   /// When the ImplicitCode flag is true, it means that the Instruction
   /// with this DILocation has been added by the front-end but it hasn't been
   /// written explicitly by the user (e.g. cleanup stuff in C++ put on a closing
   /// bracket). It's useful for code coverage to not show a counter on "empty"
   /// lines.
   bool isImplicitCode() const { return SubclassData1; }
   void setImplicitCode(bool ImplicitCode) { SubclassData1 = ImplicitCode; }
public:
 
   /// Returns the copy identifier for a given encoded discriminator \p D.
   static unsigned getCopyIdentifierFromDiscriminator(unsigned D) {
     return getUnsignedFromPrefixEncoding(
         getNextComponentInDiscriminator(getNextComponentInDiscriminator(D)));
   }
 
   Metadata *getRawScope() const { return getOperand(0); }
-  Metadata *getRawInlinedAt() const {
-    if (getNumOperands() == 2)
-      return getOperand(1);
-    return nullptr;
-  }
+  Metadata *getRawInlinedAt() const { return getOperand(1); }
+  Metadata *getRawParameters() const { return getOperand(2); }
 
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == DILocationKind;
   }
 };
 
+/// Argument value on call site.
+class DICallSiteParam : public DINode {
+  friend class LLVMContextImpl;
+  friend class MDNode;
+  int ArgNum;
+
+  DICallSiteParam(LLVMContext &Context, StorageType Storage, int ArgNum,
+                  ArrayRef<Metadata *> Ops)
+      : DINode(Context, DICallSiteParamKind, Storage,
+               dwarf::DW_TAG_call_site_parameter, Ops),
+        ArgNum(ArgNum) {}
+  ~DICallSiteParam() = default;
+
+  static DICallSiteParam *getImpl(LLVMContext &Context, int ArgNum,
+                                  DIExpression *Expr, StorageType Storage,
+                                  bool ShouldCreate = true) {
+    return getImpl(Context, ArgNum, cast<Metadata>(Expr), Storage,
+                   ShouldCreate);
+  }
+
+  static DICallSiteParam *getImpl(LLVMContext &Context, int ArgNum,
+                                  Metadata *Expr, StorageType Storage,
+                                  bool ShouldCreate = true);
+
+  TempDICallSiteParam cloneImpl() const {
+    return getTemporary(getContext(), getArgNum(), getExpression());
+  }
+
+public:
+  DEFINE_MDNODE_GET(DICallSiteParam, (int ArgNum, DIExpression *Expr),
+                    (ArgNum, Expr))
+  DEFINE_MDNODE_GET(DICallSiteParam, (int ArgNum, Metadata *Expr),
+                    (ArgNum, Expr))
+
+  int getArgNum() const { return ArgNum; }
+
+  DIExpression *getExpression() const {
+    return cast<DIExpression>(getRawExpression());
+  }
+
+  Metadata *getRawExpression() const { return getOperand(0); }
+  TempDICallSiteParam clone() const { return cloneImpl(); }
+
+  static bool classof(const Metadata *MD) {
+    return MD->getMetadataID() == DICallSiteParamKind;
+  }
+};
+
 /// Subprogram description.
 class DISubprogram : public DILocalScope {
   friend class LLVMContextImpl;
   friend class MDNode;
 
   unsigned Line;
   unsigned ScopeLine;
   unsigned VirtualIndex;

llvm/include/llvm/IR/Metadata.def

 HANDLE_SPECIALIZED_MDNODE_BRANCH(DITemplateParameter)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DITemplateTypeParameter)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DITemplateValueParameter)
 HANDLE_SPECIALIZED_MDNODE_BRANCH(DIVariable)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIGlobalVariable)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DILocalVariable)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DILabel)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIObjCProperty)
+HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DICallSiteParam)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIImportedEntity)
 HANDLE_SPECIALIZED_MDNODE_BRANCH(DIMacroNode)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIMacro)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIMacroFile)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DICommonBlock)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIArgList)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIStringType)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIGenericSubrange)

llvm/lib/AsmParser/LLParser.cpp

if (parseMDFieldsImpl(                                                     \
       return true;                                                             \
     VISIT_MD_FIELDS(NOP_FIELD, REQUIRE_FIELD)                                  \
   } while (false)
 #define GET_OR_DISTINCT(CLASS, ARGS)                                           \
   (IsDistinct ? CLASS::getDistinct ARGS : CLASS::get ARGS)
 
 /// parseDILocationFields:
 ///   ::= !DILocation(line: 43, column: 8, scope: !5, inlinedAt: !6,
-///   isImplicitCode: true)
+///   isImplicitCode: true, params: !1)
 bool LLParser::parseDILocation(MDNode *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   OPTIONAL(line, LineField, );                                                 \
   OPTIONAL(column, ColumnField, );                                             \
   REQUIRED(scope, MDField, (/* AllowNull */ false));                           \
   OPTIONAL(inlinedAt, MDField, );                                              \
-  OPTIONAL(isImplicitCode, MDBoolField, (false));
+  OPTIONAL(isImplicitCode, MDBoolField, (false));                              \
+  OPTIONAL(params, MDField, );
   PARSE_MD_FIELDS();
 #undef VISIT_MD_FIELDS
 
-  Result =
-      GET_OR_DISTINCT(DILocation, (Context, line.Val, column.Val, scope.Val,
-                                   inlinedAt.Val, isImplicitCode.Val));
+  Result = GET_OR_DISTINCT(DILocation,
+                           (Context, line.Val, column.Val, scope.Val,
+                            inlinedAt.Val, isImplicitCode.Val, params.Val));
   return false;
 }
 
 /// parseGenericDINode:
 ///   ::= !GenericDINode(tag: 15, header: "...", operands: {...})
 bool LLParser::parseGenericDINode(MDNode *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(tag, DwarfTagField, );                                              \

 #undef VISIT_MD_FIELDS
 
   Result = GET_OR_DISTINCT(DIObjCProperty,
                            (Context, name.Val, file.Val, line.Val, setter.Val,
                             getter.Val, attributes.Val, type.Val));
   return false;
 }
 
+/// ParseDICallSiteParam:
+///   ::= !DICallSiteParam(argnum: 1, expr: !1)
+bool LLParser::parseDICallSiteParam(MDNode *&Result, bool IsDistinct) {
+#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
+  OPTIONAL(argnum, MDUnsignedField, (0, INT32_MAX));                           \
+  OPTIONAL(expr, MDField, );
+  PARSE_MD_FIELDS();
+#undef VISIT_MD_FIELDS
+
+  Result = GET_OR_DISTINCT(DICallSiteParam, (Context, argnum.Val, expr.Val));
+  return false;
+}
+
 /// parseDIImportedEntity:
 ///   ::= !DIImportedEntity(tag: DW_TAG_imported_module, scope: !0, entity: !1,
 ///                         line: 7, name: "foo", elements: !2)
 bool LLParser::parseDIImportedEntity(MDNode *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(tag, DwarfTagField, );                                              \
   REQUIRED(scope, MDField, );                                                  \
   OPTIONAL(entity, MDField, );                                                 \

llvm/lib/Bitcode/Reader/MetadataLoader.cpp

#endif
       case bitc::METADATA_MACRO_FILE:
       case bitc::METADATA_TEMPLATE_TYPE:
       case bitc::METADATA_TEMPLATE_VALUE:
       case bitc::METADATA_GLOBAL_VAR:
       case bitc::METADATA_LOCAL_VAR:
       case bitc::METADATA_LABEL:
       case bitc::METADATA_EXPRESSION:
       case bitc::METADATA_OBJC_PROPERTY:
+      case bitc::METADATA_CALL_SITE_PARAM:
       case bitc::METADATA_IMPORTED_ENTITY:
       case bitc::METADATA_GLOBAL_VAR_EXPR:
       case bitc::METADATA_GENERIC_SUBRANGE:
         // We don't expect to see any of these, if we see one, give up on
         // lazy-loading and fallback.
         MDStringRef.clear();
         GlobalMetadataBitPosIndex.clear();
         return false;
for (unsigned ID : Record)
       Elts.push_back(getMDOrNull(ID));
     MetadataList.assignValue(IsDistinct ? MDNode::getDistinct(Context, Elts)
                                         : MDNode::get(Context, Elts),
                              NextMetadataNo);
     NextMetadataNo++;
     break;
   }
   case bitc::METADATA_LOCATION: {
-    if (Record.size() != 5 && Record.size() != 6)
+    if (Record.size() != 5 && Record.size() != 6 && Record.size() != 7)
       return error("Invalid record");
 
     IsDistinct = Record[0];
     unsigned Line = Record[1];
     unsigned Column = Record[2];
     Metadata *Scope = getMD(Record[3]);
     Metadata *InlinedAt = getMDOrNull(Record[4]);
-    bool ImplicitCode = Record.size() == 6 && Record[5];
+    bool ImplicitCode = false;
+    Metadata *Params = nullptr;
+    if (Record.size() > 5)
+      ImplicitCode = Record[5];
+    if (Record.size() > 6)
+      Params = getMDOrNull(Record[6]);
     MetadataList.assignValue(
         GET_OR_DISTINCT(DILocation, (Context, Line, Column, Scope, InlinedAt,
-                                     ImplicitCode)),
+                                     ImplicitCode, Params)),
         NextMetadataNo);
     NextMetadataNo++;
     break;
   }
   case bitc::METADATA_GENERIC_DEBUG: {
     if (Record.size() < 4)
       return error("Invalid record");
 
MetadataList.assignValue(
                         (Context, getMDString(Record[1]),
                          getMDOrNull(Record[2]), Record[3],
                          getMDString(Record[4]), getMDString(Record[5]),
                          Record[6], getDITypeRefOrNull(Record[7]))),
         NextMetadataNo);
     NextMetadataNo++;
     break;
   }
+  case bitc::METADATA_CALL_SITE_PARAM: {
+    IsDistinct = Record[0];
+    MetadataList.assignValue(
+        GET_OR_DISTINCT(DICallSiteParam,
+                        (Context, Record[1], getMDOrNull(Record[2]))),
+        NextMetadataNo);
+    NextMetadataNo++;
+    break;
+  }
   case bitc::METADATA_IMPORTED_ENTITY: {
     if (Record.size() < 6 && Record.size() > 8)
       return error("Invalid record");
 
     IsDistinct = Record[0];
     bool HasFile = (Record.size() >= 7);
     bool HasElements = (Record.size() >= 8);
     MetadataList.assignValue(

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

void writeDILabel(const DILabel *N,
                     SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
   void writeDIExpression(const DIExpression *N,
                          SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
   void writeDIGlobalVariableExpression(const DIGlobalVariableExpression *N,
                                        SmallVectorImpl<uint64_t> &Record,
                                        unsigned Abbrev);
   void writeDIObjCProperty(const DIObjCProperty *N,
                            SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
+  void writeDICallSiteParam(const DICallSiteParam *N,
+                            SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
   void writeDIImportedEntity(const DIImportedEntity *N,
                              SmallVectorImpl<uint64_t> &Record,
                              unsigned Abbrev);
   unsigned createNamedMetadataAbbrev();
   void writeNamedMetadata(SmallVectorImpl<uint64_t> &Record);
   unsigned createMetadataStringsAbbrev();
   void writeMetadataStrings(ArrayRef<const Metadata *> Strings,
                             SmallVectorImpl<uint64_t> &Record);
unsigned ModuleBitcodeWriter::createDILocationAbbrev() {
   auto Abbv = std::make_shared<BitCodeAbbrev>();
   Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_LOCATION));
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
   return Stream.EmitAbbrev(std::move(Abbv));
 }
 
 void ModuleBitcodeWriter::writeDILocation(const DILocation *N,
                                           SmallVectorImpl<uint64_t> &Record,
                                           unsigned &Abbrev) {
   if (!Abbrev)
     Abbrev = createDILocationAbbrev();
 
   Record.push_back(N->isDistinct());
   Record.push_back(N->getLine());
   Record.push_back(N->getColumn());
   Record.push_back(VE.getMetadataID(N->getScope()));
   Record.push_back(VE.getMetadataOrNullID(N->getInlinedAt()));
   Record.push_back(N->isImplicitCode());
+  Record.push_back(VE.getMetadataOrNullID(N->getRawParameters()));
 
   Stream.EmitRecord(bitc::METADATA_LOCATION, Record, Abbrev);
   Record.clear();
 }
 
 unsigned ModuleBitcodeWriter::createGenericDINodeAbbrev() {
   // Assume the column is usually under 128, and always output the inlined-at
   // location (it's never more expensive than building an array size 1).
void ModuleBitcodeWriter::writeDIObjCProperty(const DIObjCProperty *N,
   Record.push_back(VE.getMetadataOrNullID(N->getRawGetterName()));
   Record.push_back(N->getAttributes());
   Record.push_back(VE.getMetadataOrNullID(N->getType()));
 
   Stream.EmitRecord(bitc::METADATA_OBJC_PROPERTY, Record, Abbrev);
   Record.clear();
 }
 
+void ModuleBitcodeWriter::writeDICallSiteParam(
+    const DICallSiteParam *N, SmallVectorImpl<uint64_t> &Record,
+    unsigned Abbrev) {
+  Record.push_back(N->isDistinct());
+  Record.push_back(N->getArgNum());
+  Record.push_back(VE.getMetadataOrNullID(N->getExpression()));
+
+  Stream.EmitRecord(bitc::METADATA_CALL_SITE_PARAM, Record, Abbrev);
+  Record.clear();
+}
+
 void ModuleBitcodeWriter::writeDIImportedEntity(
     const DIImportedEntity *N, SmallVectorImpl<uint64_t> &Record,
     unsigned Abbrev) {
   Record.push_back(N->isDistinct());
   Record.push_back(N->getTag());
   Record.push_back(VE.getMetadataOrNullID(N->getScope()));
   Record.push_back(VE.getMetadataOrNullID(N->getEntity()));
   Record.push_back(N->getLine());

llvm/lib/IR/AsmWriter.cpp

static void writeDILocation(raw_ostream &Out, const DILocation *DL,
   MDFieldPrinter Printer(Out, WriterCtx);
   // Always output the line, since 0 is a relevant and important value for it.
   Printer.printInt("line", DL->getLine(), /* ShouldSkipZero */ false);
   Printer.printInt("column", DL->getColumn());
   Printer.printMetadata("scope", DL->getRawScope(), /* ShouldSkipNull */ false);
   Printer.printMetadata("inlinedAt", DL->getRawInlinedAt());
   Printer.printBool("isImplicitCode", DL->isImplicitCode(),
                     /* Default */ false);
+  Printer.printMetadata("params", DL->getRawParameters());
   Out << ")";
 }
 
 static void writeDISubrange(raw_ostream &Out, const DISubrange *N,
                             AsmWriterContext &WriterCtx) {
   Out << "!DISubrange(";
   MDFieldPrinter Printer(Out, WriterCtx);
 
static void writeDIObjCProperty(raw_ostream &Out, const DIObjCProperty *N,
   Printer.printInt("line", N->getLine());
   Printer.printString("setter", N->getSetterName());
   Printer.printString("getter", N->getGetterName());
   Printer.printInt("attributes", N->getAttributes());
   Printer.printMetadata("type", N->getRawType());
   Out << ")";
 }
 
+static void writeDICallSiteParam(raw_ostream &Out, const DICallSiteParam *N,
+                                 AsmWriterContext &WriteCtx) {
+  Out << "!DICallSiteParam(";
+  MDFieldPrinter Printer(Out, WriteCtx);
+  Printer.printInt("argnum", N->getArgNum(), false);
+  Printer.printMetadata("expr", N->getRawExpression());
+  Out << ")";
+}
+
 static void writeDIImportedEntity(raw_ostream &Out, const DIImportedEntity *N,
                                   AsmWriterContext &WriterCtx) {
   Out << "!DIImportedEntity(";
   MDFieldPrinter Printer(Out, WriterCtx);
   Printer.printTag(N);
   Printer.printString("name", N->getName());
   Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
   Printer.printMetadata("entity", N->getRawEntity());

llvm/lib/IR/DebugInfoMetadata.cpp

 
 const DIExpression::FragmentInfo DebugVariable::DefaultFragment = {
     std::numeric_limits<uint64_t>::max(), std::numeric_limits<uint64_t>::min()};
 
 DILocation::DILocation(LLVMContext &C, StorageType Storage, unsigned Line,
                        unsigned Column, ArrayRef<Metadata *> MDs,
                        bool ImplicitCode)
     : MDNode(C, DILocationKind, Storage, MDs) {
-  assert((MDs.size() == 1 || MDs.size() == 2) &&
-         "Expected a scope and optional inlined-at");
+  assert((MDs.size() == 1 || MDs.size() == 2 || MDs.size() == 3) &&
+         "Expected a scope and optional inlined-at and params");
 
   // Set line and column.
   assert(Column < (1u << 16) && "Expected 16-bit column");
 
   SubclassData32 = Line;
   SubclassData16 = Column;
 
   setImplicitCode(ImplicitCode);
 }
 
 static void adjustColumn(unsigned &Column) {
   // Set to unknown on overflow.  We only have 16 bits to play with here.
   if (Column >= (1u << 16))
     Column = 0;
 }
 
 DILocation *DILocation::getImpl(LLVMContext &Context, unsigned Line,
                                 unsigned Column, Metadata *Scope,
                                 Metadata *InlinedAt, bool ImplicitCode,
-                                StorageType Storage, bool ShouldCreate) {
+                                Metadata *Parameters, StorageType Storage,
+                                bool ShouldCreate) {
   // Fixup column.
   adjustColumn(Column);
 
   if (Storage == Uniqued) {
-    if (auto *N = getUniqued(Context.pImpl->DILocations,
-                             DILocationInfo::KeyTy(Line, Column, Scope,
-                                                   InlinedAt, ImplicitCode)))
+    if (auto *N =
+            getUniqued(Context.pImpl->DILocations,
+                       DILocationInfo::KeyTy(Line, Column, Scope, InlinedAt,
+                                             ImplicitCode, Parameters)))
       return N;
     if (!ShouldCreate)
       return nullptr;
   } else {
     assert(ShouldCreate && "Expected non-uniqued nodes to always be created");
   }
 
-  SmallVector<Metadata *, 2> Ops;
+  SmallVector<Metadata *, 3> Ops;
   Ops.push_back(Scope);
   if (InlinedAt)
     Ops.push_back(InlinedAt);
+  else {
+    Ops.push_back(nullptr);
+  }
+  if (Parameters)
+    Ops.push_back(Parameters);
+  else {
+    Ops.push_back(nullptr);
+  }
   return storeImpl(new (Ops.size()) DILocation(Context, Storage, Line, Column,
                                                Ops, ImplicitCode),
                    Storage, Context.pImpl->DILocations);
 }
 
 const DILocation *
 DILocation::getMergedLocations(ArrayRef<const DILocation *> Locs) {
   if (Locs.empty())
DIObjCProperty *DIObjCProperty::getImpl(
   assert(isCanonical(GetterName) && "Expected canonical MDString");
   assert(isCanonical(SetterName) && "Expected canonical MDString");
   DEFINE_GETIMPL_LOOKUP(DIObjCProperty, (Name, File, Line, GetterName,
                                          SetterName, Attributes, Type));
   Metadata *Ops[] = {Name, File, GetterName, SetterName, Type};
   DEFINE_GETIMPL_STORE(DIObjCProperty, (Line, Attributes), Ops);
 }
 
+DICallSiteParam *DICallSiteParam::getImpl(LLVMContext &Context, int ArgNum,
+                                     Metadata *Expr,
+                                    StorageType Storage, bool ShouldCreate) {
+  DEFINE_GETIMPL_LOOKUP(DICallSiteParam, (ArgNum, Expr));
+  Metadata *Ops[] = {Expr};
+  DEFINE_GETIMPL_STORE(DICallSiteParam, (ArgNum), Ops);
+}
+
 DIImportedEntity *DIImportedEntity::getImpl(LLVMContext &Context, unsigned Tag,
                                             Metadata *Scope, Metadata *Entity,
                                             Metadata *File, unsigned Line,
                                             MDString *Name, Metadata *Elements,
                                             StorageType Storage,
                                             bool ShouldCreate) {
   assert(isCanonical(Name) && "Expected canonical MDString");
   DEFINE_GETIMPL_LOOKUP(DIImportedEntity,

llvm/lib/IR/LLVMContextImpl.h

 
 /// DenseMapInfo for DILocation.
 template <> struct MDNodeKeyImpl<DILocation> {
   unsigned Line;
   unsigned Column;
   Metadata *Scope;
   Metadata *InlinedAt;
   bool ImplicitCode;
+  Metadata *Parameters;
 
   MDNodeKeyImpl(unsigned Line, unsigned Column, Metadata *Scope,
-                Metadata *InlinedAt, bool ImplicitCode)
+                Metadata *InlinedAt, bool ImplicitCode, Metadata *Parameters)
       : Line(Line), Column(Column), Scope(Scope), InlinedAt(InlinedAt),
-        ImplicitCode(ImplicitCode) {}
+        ImplicitCode(ImplicitCode), Parameters(Parameters) {}
   MDNodeKeyImpl(const DILocation *L)
       : Line(L->getLine()), Column(L->getColumn()), Scope(L->getRawScope()),
-        InlinedAt(L->getRawInlinedAt()), ImplicitCode(L->isImplicitCode()) {}
+        InlinedAt(L->getRawInlinedAt()), ImplicitCode(L->isImplicitCode()),
+        Parameters(L->getRawParameters()) {}
 
   bool isKeyOf(const DILocation *RHS) const {
     return Line == RHS->getLine() && Column == RHS->getColumn() &&
            Scope == RHS->getRawScope() && InlinedAt == RHS->getRawInlinedAt() &&
-           ImplicitCode == RHS->isImplicitCode();
+           ImplicitCode == RHS->isImplicitCode() &&
+           Parameters == RHS->getRawParameters();
   }
 
   unsigned getHashValue() const {
     return hash_combine(Line, Column, Scope, InlinedAt, ImplicitCode);
   }
 };
 
 /// DenseMapInfo for GenericDINode.
template <> struct MDNodeKeyImpl<DIObjCProperty> {
   }
 
   unsigned getHashValue() const {
     return hash_combine(Name, File, Line, GetterName, SetterName, Attributes,
                         Type);
   }
 };
 
+template <> struct MDNodeKeyImpl<DICallSiteParam> {
+  int ArgNum;
+  Metadata *Expr;
+  MDNodeKeyImpl(int ArgNum, Metadata *Expr) : ArgNum(ArgNum), Expr(Expr) {}
+  MDNodeKeyImpl(const DICallSiteParam *N)
+      : ArgNum(N->getArgNum()), Expr(N->getRawExpression()) {}
+  bool isKeyOf(const DICallSiteParam *RHS) const {
+    return ArgNum == RHS->getArgNum() && Expr == RHS->getRawExpression();
+  }
+
+  unsigned getHashValue() const { return hash_combine(ArgNum, Expr); }
+};
+
 template <> struct MDNodeKeyImpl<DIImportedEntity> {
   unsigned Tag;
   Metadata *Scope;
   Metadata *Entity;
   Metadata *File;
   unsigned Line;
   MDString *Name;
   Metadata *Elements;

llvm/lib/IR/Verifier.cpp

 void Verifier::visitDIObjCProperty(const DIObjCProperty &N) {
   AssertDI(N.getTag() == dwarf::DW_TAG_APPLE_property, "invalid tag", &N);
   if (auto *T = N.getRawType())
     AssertDI(isType(T), "invalid type ref", &N, T);
   if (auto *F = N.getRawFile())
     AssertDI(isa<DIFile>(F), "invalid file", &N, F);
 }
 
+void Verifier::visitDICallSiteParam(const DICallSiteParam &N) {
+  AssertDI(N.getTag() == dwarf::DW_TAG_call_site_parameter, "invalid tag", &N);
+}
+
 void Verifier::visitDIImportedEntity(const DIImportedEntity &N) {
   AssertDI(N.getTag() == dwarf::DW_TAG_imported_module ||
                N.getTag() == dwarf::DW_TAG_imported_declaration,
            "invalid tag", &N);
   if (auto *S = N.getRawScope())
     AssertDI(isa<DIScope>(S), "invalid scope for imported entity", &N, S);
   AssertDI(isDINode(N.getRawEntity()), "invalid imported entity", &N,
            N.getRawEntity());