[Metadata] Introduce call site dbg info metadata

[djtodoro]

Summary

As discussed on RFC (http://lists.llvm.org/pipermail/llvm-dev/2019-February/130094.html), this is set of patches that introduce debug information about call site and call site parameters. Since LLVM has portion of this support (dumping DWARF 5 symbols for tail calls), we generate all this information as GNU extensions for now. All of that will be restricted under an option, until we do all necessary testing and patching.

This is first patch in the set and it introduces IR level debug information about call sites and call site parameters. It follows the way of the LLVM guidelines for introducing DI metadata in the front end and carrying in through IR and MIR.

DICallSite wraps all information about call sites.
DICallSiteParam represents debug information about call site parameter. It provides backup location once primary location that is loaded into parameter forwarding register is lost, but with providing DICallSiteParam we also provide ability to look two or more frames behind in order to search for called function entry values.

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.

[asowda]

@aprantl Sure, let us continue discussion on RFC thread in llvm-dev.

include/llvm-c/DebugInfo.h

enum {
   LLVMDITemplateTypeParameterMetadataKind,
   LLVMDITemplateValueParameterMetadataKind,
   LLVMDIGlobalVariableMetadataKind,
   LLVMDILocalVariableMetadataKind,
   LLVMDILabelMetadataKind,
   LLVMDIObjCPropertyMetadataKind,
   LLVMDIImportedEntityMetadataKind,
   LLVMDIMacroMetadataKind,
-  LLVMDIMacroFileMetadataKind
+  LLVMDIMacroFileMetadataKind,
+  LLVMDICallSiteMetadataKind,
+  LLVMDICallSiteParamMetadataKind
 };
 typedef unsigned LLVMMetadataKind;
 
 /**
  * An LLVM DWARF type encoding.
  */
 typedef unsigned LLVMDWARFTypeEncoding;
 

include/llvm/BinaryFormat/Dwarf.def

 HANDLE_DW_AT(0x2103, mac_info, 0, GNU)
 HANDLE_DW_AT(0x2104, src_coords, 0, GNU)
 HANDLE_DW_AT(0x2105, body_begin, 0, GNU)
 HANDLE_DW_AT(0x2106, body_end, 0, GNU)
 HANDLE_DW_AT(0x2107, GNU_vector, 0, GNU)
 HANDLE_DW_AT(0x2110, GNU_template_name, 0, GNU)
 HANDLE_DW_AT(0x210f, GNU_odr_signature, 0, GNU)
 HANDLE_DW_AT(0x2111, GNU_call_site_value, 0, GNU)
+HANDLE_DW_AT (0x2112, GNU_call_site_data_value, 0, GNU)
+HANDLE_DW_AT (0x2113, GNU_call_site_target, 0, GNU)
+HANDLE_DW_AT (0x2114, GNU_call_site_target_clobbered, 0, GNU)
+HANDLE_DW_AT (0x2115, GNU_tail_call, 0, GNU)
+HANDLE_DW_AT (0x2116, GNU_all_tail_call_sites, 0, GNU)
 HANDLE_DW_AT(0x2117, GNU_all_call_sites, 0, GNU)
+HANDLE_DW_AT (0x2118, GNU_all_source_call_sites, 0, GNU)
 HANDLE_DW_AT(0x2119, GNU_macros, 0, GNU)
 // Extensions for Fission proposal.
 HANDLE_DW_AT(0x2130, GNU_dwo_name, 0, GNU)
 HANDLE_DW_AT(0x2131, GNU_dwo_id, 0, GNU)
 HANDLE_DW_AT(0x2132, GNU_ranges_base, 0, GNU)
 HANDLE_DW_AT(0x2133, GNU_addr_base, 0, GNU)
 HANDLE_DW_AT(0x2134, GNU_pubnames, 0, GNU)
 HANDLE_DW_AT(0x2135, GNU_pubtypes, 0, GNU)

include/llvm/Bitcode/LLVMBitCodes.h

enum MetadataCodes {
   METADATA_MACRO = 33,           // [distinct, macinfo, line, name, value]
   METADATA_MACRO_FILE = 34,      // [distinct, macinfo, line, file, ...]
   METADATA_STRINGS = 35,         // [count, offset] blob([lengths][chars])
   METADATA_GLOBAL_DECL_ATTACHMENT = 36, // [valueid, n x [id, mdnode]]
   METADATA_GLOBAL_VAR_EXPR = 37,        // [distinct, var, expr]
   METADATA_INDEX_OFFSET = 38,           // [offset]
   METADATA_INDEX = 39,                  // [bitpos]
   METADATA_LABEL = 40,                  // [distinct, scope, name, file, line]
+  METADATA_CALL_SITE = 41,           // [distinct, scope, parameters, line, calledSubprogram]
+  METADATA_CALL_SITE_PARAM = 42,     // [distinct, argno, var, 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

include/llvm/IR/DebugInfoFlags.def

 HANDLE_DISP_FLAG(0, Zero)
 // Virtuality is a two-bit enum field in the LSB of the word.
 // Values should match DW_VIRTUALITY_*.
 HANDLE_DISP_FLAG(1u, Virtual)
 HANDLE_DISP_FLAG(2u, PureVirtual)
 HANDLE_DISP_FLAG((1u << 2), LocalToUnit)
 HANDLE_DISP_FLAG((1u << 3), Definition)
 HANDLE_DISP_FLAG((1u << 4), Optimized)
+HANDLE_DISP_FLAG((1u << 5), AllCallsDesc)
+HANDLE_DISP_FLAG((1u << 6), DeclForCallSite)
 
 #ifdef DISP_FLAG_LARGEST_NEEDED
 // Intended to be used with ADT/BitmaskEnum.h.
 // NOTE: Always must be equal to largest flag, check this when adding new flags.
-HANDLE_DISP_FLAG((1 << 4), Largest)
+HANDLE_DISP_FLAG((1 << 6), Largest)
 #undef DISP_FLAG_LARGEST_NEEDED
 #endif
 
 #undef HANDLE_DI_FLAG
 #undef HANDLE_DISP_FLAG

include/llvm/IR/DebugInfoMetadata.h

static bool classof(const Metadata *MD) {
     case DIEnumeratorKind:
     case DIBasicTypeKind:
     case DIDerivedTypeKind:
     case DICompositeTypeKind:
     case DISubroutineTypeKind:
     case DIFileKind:
     case DICompileUnitKind:
     case DISubprogramKind:
+    case DICallSiteKind:
+    case DICallSiteParamKind:
     case DILexicalBlockKind:
     case DILexicalBlockFileKind:
     case DINamespaceKind:
     case DITemplateTypeParameterKind:
     case DITemplateValueParameterKind:
     case DIGlobalVariableKind:
     case DILocalVariableKind:
     case DILabelKind:
default:
       return false;
     case DIBasicTypeKind:
     case DIDerivedTypeKind:
     case DICompositeTypeKind:
     case DISubroutineTypeKind:
     case DIFileKind:
     case DICompileUnitKind:
     case DISubprogramKind:
+    case DICallSiteKind:
     case DILexicalBlockKind:
     case DILexicalBlockFileKind:
     case DINamespaceKind:
     case DIModuleKind:
       return true;
     }
   }
 };
return static_cast<DISPFlags>(
         (Virtuality & SPFlagVirtuality) |
         (IsLocalToUnit ? SPFlagLocalToUnit : SPFlagZero) |
         (IsDefinition ? SPFlagDefinition : SPFlagZero) |
         (IsOptimized ? SPFlagOptimized : SPFlagZero));
   }
 
 private:
   DIFlags Flags;
-  DISPFlags SPFlags;
+  mutable DISPFlags SPFlags;
 
   DISubprogram(LLVMContext &C, StorageType Storage, unsigned Line,
                unsigned ScopeLine, unsigned VirtualIndex, int ThisAdjustment,
                DIFlags Flags, DISPFlags SPFlags, ArrayRef<Metadata *> Ops)
       : DILocalScope(C, DISubprogramKind, Storage, dwarf::DW_TAG_subprogram,
                      Ops),
         Line(Line), ScopeLine(ScopeLine), VirtualIndex(VirtualIndex),
         ThisAdjustment(ThisAdjustment), Flags(Flags), SPFlags(SPFlags) {
public:
   int getThisAdjustment() const { return ThisAdjustment; }
   unsigned getScopeLine() const { return ScopeLine; }
   DIFlags getFlags() const { return Flags; }
   DISPFlags getSPFlags() const { return SPFlags; }
   bool isLocalToUnit() const { return getSPFlags() & SPFlagLocalToUnit; }
   bool isDefinition() const { return getSPFlags() & SPFlagDefinition; }
   bool isOptimized() const { return getSPFlags() & SPFlagOptimized; }
 
+  /// Used for debug info about call sites.
+  bool getIsDesribedByCallSites() const { return getSPFlags() & SPFlagAllCallsDesc; }
+  void setIsDesribedByCallSites() { getSPFlags() | SPFlagAllCallsDesc; }
+  void setIsDesribedByCallSites() const { getSPFlags() | SPFlagAllCallsDesc; }
+  bool getIsDeclForCallSite() const { return getSPFlags() & SPFlagDeclForCallSite; }
+  void setIsDeclForCallSite() { getSPFlags() | SPFlagDeclForCallSite; }
+
   bool isArtificial() const { return getFlags() & FlagArtificial; }
   bool isPrivate() const {
     return (getFlags() & FlagAccessibility) == FlagPrivate;
   }
   bool isProtected() const {
     return (getFlags() & FlagAccessibility) == FlagProtected;
   }
   bool isPublic() const {
public:
   }
   DINodeArray getRetainedNodes() const {
     return cast_or_null<MDTuple>(getRawRetainedNodes());
   }
   DITypeArray getThrownTypes() const {
     return cast_or_null<MDTuple>(getRawThrownTypes());
   }
 
+  void replaceElements(DINodeArray Elements) {
+    replaceOperandWith(10, Elements.get());
+  }
+
   Metadata *getRawScope() const { return getOperand(1); }
   MDString *getRawName() const { return getOperandAs<MDString>(2); }
   MDString *getRawLinkageName() const { return getOperandAs<MDString>(3); }
   Metadata *getRawType() const { return getOperand(4); }
   Metadata *getRawUnit() const { return getOperand(5); }
   Metadata *getRawDeclaration() const { return getOperand(6); }
   Metadata *getRawRetainedNodes() const { return getOperand(7); }
   Metadata *getRawContainingType() const {
public:
   /// FIXME: Should this be looking through bitcasts?
   bool describes(const Function *F) const;
 
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == DISubprogramKind;
   }
 };
 
+class DICallSite : public DINode {
+  friend class LLVMContextImpl;
+  friend class MDNode;
+
+  unsigned Line;
+
+  DICallSite(LLVMContext &C, StorageType Storage, unsigned Line,
+             ArrayRef<Metadata *> Ops)
+      : DINode(C, DICallSiteKind, Storage, dwarf::DW_TAG_GNU_call_site, Ops),
+        Line(Line){};
+  ~DICallSite() { dropAllReferences(); }
+
+  static DICallSite *getImpl(LLVMContext &Context, DIScope *Scope, DIFile *File,
+                             DINodeArray Params, unsigned Line,
+                             DISubprogram *CalledSubprogram,
+                             StorageType Storage, bool ShouldCreate = true) {
+    return getImpl(Context, Scope, File, cast_or_null<Metadata>(Params.get()),
+                   Line, CalledSubprogram, Storage, ShouldCreate);
+  }
+
+  static DICallSite *getImpl(LLVMContext &Context, Metadata *Scope,
+                             Metadata *File, Metadata *Params, unsigned Line,
+                             Metadata *CalledSubprogram, StorageType Storage,
+                             bool ShouldCreate = true);
+
+  TempDICallSite cloneImpl() const {
+    return getTemporary(getContext(), getScope(), getFile(), getParameters(),
+                        getLine(), getCalledSubprogram());
+  }
+
+public:
+  DEFINE_MDNODE_GET(DICallSite,
+                    (DILocalScope * Scope, DIFile *File, DINodeArray Params,
+                     unsigned Line, DISubprogram *CalledSubprogram),
+                    (Scope, File, Params, Line, CalledSubprogram))
+  DEFINE_MDNODE_GET(DICallSite,
+                    (Metadata * Scope, Metadata *File, Metadata *Params,
+                     unsigned Line, Metadata *CalledSubprogram),
+                    (Scope, File, Params, Line, CalledSubprogram))
+
+  TempDICallSite clone() const { return cloneImpl(); }
+
+  DILocalScope *getScope() const {
+    return cast_or_null<DILocalScope>(getRawScope());
+  }
+
+  unsigned getLine() const { return Line; }
+  DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
+  DISubprogram *getCalledSubprogram() const {
+    return cast_or_null<DISubprogram>(getRawCalledSubprogram());
+  }
+
+  Metadata *getRawScope() const { return getOperand(0); }
+  Metadata *getRawFile() const { return getOperand(1); }
+  DINodeArray getParameters() const {
+    return cast_or_null<MDTuple>(getRawParams());
+  }
+  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();
+  }
+
+  static bool classof(const Metadata *MD) {
+    return MD->getMetadataID() == DICallSiteKind;
+  }
+};
+
+class DICallSiteParam : public DINode {
+  friend class LLVMContextImpl;
+  friend class MDNode;
+
+  unsigned ArgNo;
+
+  DICallSiteParam(LLVMContext &C, StorageType Storage, unsigned ArgNo,
+                  ArrayRef<Metadata *> Ops)
+      : DINode(C, DICallSiteParamKind, Storage,
+               dwarf::DW_TAG_GNU_call_site_parameter, Ops),
+        ArgNo(ArgNo) {}
+  ~DICallSiteParam() = default;
+  // TODO :: CONSIDER ONE getImpl and one DEFINE_MDNODE_GE like in
+  // GlobalDIExpression
+  static DICallSiteParam *getImpl(LLVMContext &Context, unsigned ArgNo,
+                                  DILocalVariable *Var, DIExpression *Expr,
+                                  StorageType Storage,
+                                  bool ShouldCreate = true) {
+    return getImpl(Context, ArgNo, cast_or_null<Metadata>(Var),
+                   cast<Metadata>(Expr), Storage, ShouldCreate);
+  }
+
+  static DICallSiteParam *getImpl(LLVMContext &Context, unsigned ArgNo,
+                                  Metadata *Var, Metadata *Expr,
+                                  StorageType Storage,
+                                  bool ShouldCreate = true);
+
+  TempDICallSiteParam cloneImpl() const {
+    return getTemporary(getContext(), getArgNo(), getVar(), getExpression());
+  }
+
+public:
+  DEFINE_MDNODE_GET(DICallSiteParam,
+                    (unsigned ArgNo, DILocalVariable *Var, DIExpression *Expr),
+                    (ArgNo, Var, Expr))
+  DEFINE_MDNODE_GET(DICallSiteParam,
+                    (unsigned ArgNo, Metadata *Var, Metadata *Expr),
+                    (ArgNo, Var, Expr))
+  DEFINE_MDNODE_GET(DICallSiteParam, (unsigned ArgNo, Metadata *Expr),
+                    (ArgNo, nullptr, Expr))
+  DEFINE_MDNODE_GET(DICallSiteParam, (unsigned ArgNo, DIExpression *Expr),
+                    (ArgNo, nullptr, Expr))
+
+  TempDICallSiteParam clone() const { return cloneImpl(); }
+
+  unsigned getArgNo() const { return ArgNo; }
+
+  Metadata *getRawVar() const { return getOperand(0); }
+  Metadata *getRawExpression() const { return getOperand(1); }
+
+  DILocalVariable *getVar() const {
+    return cast_or_null<DILocalVariable>(getOperand(0));
+  }
+  DIExpression *getExpression() const {
+    return cast<DIExpression>(getRawExpression());
+  }
+
+  static bool classof(const Metadata *MD) {
+    return MD->getMetadataID() == DICallSiteParamKind;
+  }
+};
+
 class DILexicalBlockBase : public DILocalScope {
 protected:
   DILexicalBlockBase(LLVMContext &C, unsigned ID, StorageType Storage,
                      ArrayRef<Metadata *> Ops)
       : DILocalScope(C, ID, Storage, dwarf::DW_TAG_lexical_block, Ops) {}
   ~DILexicalBlockBase() = default;
 
 public:

include/llvm/IR/Metadata.def

 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIBasicType)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIDerivedType)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DICompositeType)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DISubroutineType)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIFile)
 HANDLE_SPECIALIZED_MDNODE_LEAF(DICompileUnit)
 HANDLE_SPECIALIZED_MDNODE_BRANCH(DILocalScope)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DISubprogram)
+HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DICallSite)
+HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DICallSiteParam)
 HANDLE_SPECIALIZED_MDNODE_BRANCH(DILexicalBlockBase)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DILexicalBlock)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DILexicalBlockFile)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DINamespace)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIModule)
 HANDLE_SPECIALIZED_MDNODE_BRANCH(DITemplateParameter)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DITemplateTypeParameter)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DITemplateValueParameter)

lib/AsmParser/LLParser.cpp

Result = GET_OR_DISTINCT(
       DISubprogram,
       (Context, scope.Val, name.Val, linkageName.Val, file.Val, line.Val,
        type.Val, scopeLine.Val, containingType.Val, virtualIndex.Val,
        thisAdjustment.Val, flags.Val, SPFlags, unit.Val, templateParams.Val,
        declaration.Val, retainedNodes.Val, thrownTypes.Val));
   return false;
 }
 
+/// ParseDICallSite:
+///   ::= !DICallSite(scope: !0, file: !2, parameters: !32, line: 7,
+///                   calledSubprogram: !12)
+bool LLParser::ParseDICallSite(MDNode *&Result, bool IsDistinct) {
+#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
+  REQUIRED(scope, MDField, (/* AllowNull */ false));                           \
+  OPTIONAL(file, MDField, );                                                   \
+  OPTIONAL(parameters, MDField, );                                             \
+  OPTIONAL(line, LineField, );                                                 \
+  OPTIONAL(calledSubprogram, MDField, );
+  PARSE_MD_FIELDS();
+#undef VISIT_MD_FIELDS
+
+  Result =
+      GET_OR_DISTINCT(DICallSite, (Context, scope.Val, file.Val, parameters.Val,
+                                   line.Val, calledSubprogram.Val));
+  return false;
+}
+
+/// ParseDICallSiteParam:
+///   ::= !DICallSiteParam(argno: 1, variable: !0, expr: !1)
+bool LLParser::ParseDICallSiteParam(MDNode *&Result, bool IsDistinct) {
+#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
+  OPTIONAL(argno, MDUnsignedField, (0, UINT16_MAX));                           \
+  OPTIONAL(variable, MDField, );                                               \
+  OPTIONAL(expr, MDField, );
+  PARSE_MD_FIELDS();
+#undef VISIT_MD_FIELDS
+
+  Result = GET_OR_DISTINCT(DICallSiteParam,
+                           (Context, argno.Val, variable.Val, expr.Val));
+  return false;
+}
+
 /// ParseDILexicalBlock:
 ///   ::= !DILexicalBlock(scope: !0, file: !2, line: 7, column: 9)
 bool LLParser::ParseDILexicalBlock(MDNode *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(scope, MDField, (/* AllowNull */ false));                           \
   OPTIONAL(file, MDField, );                                                   \
   OPTIONAL(line, LineField, );                                                 \
   OPTIONAL(column, ColumnField, );

lib/Bitcode/Reader/MetadataLoader.cpp

case BitstreamEntry::Record: {
       case bitc::METADATA_LEXICAL_BLOCK_FILE:
       case bitc::METADATA_NAMESPACE:
       case bitc::METADATA_MACRO:
       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_CALL_SITE:
+      case bitc::METADATA_CALL_SITE_PARAM:
       case bitc::METADATA_LABEL:
       case bitc::METADATA_EXPRESSION:
       case bitc::METADATA_OBJC_PROPERTY:
       case bitc::METADATA_IMPORTED_ENTITY:
       case bitc::METADATA_GLOBAL_VAR_EXPR:
         // We don't expect to see any of these, if we see one, give up on
         // lazy-loading and fallback.
         MDStringRef.clear();
if (HasFn) {
             // metadata.
             FunctionsWithSPs[F] = SP;
           else if (!F->empty())
             F->setSubprogram(SP);
         }
     }
     break;
   }
+  case bitc::METADATA_CALL_SITE: {
+    if (Record.size() != 6)
+      return error("Invalid record");
+
+    IsDistinct = Record[0] & 1;
+    MetadataList.assignValue(
+        GET_OR_DISTINCT(DICallSite,
+                        (Context, getMDOrNull(Record[1]),
+                         getMDOrNull(Record[2]), getMDOrNull(Record[3]),
+                         Record[4], getMDOrNull(Record[5]))),
+        NextMetadataNo);
+    NextMetadataNo++;
+    break;
+  }
+  case bitc::METADATA_CALL_SITE_PARAM: {
+    if (Record.size() != 3)
+      return error("Invalid record");
+
+    IsDistinct = Record[0] & 1;
+    MetadataList.assignValue(
+        GET_OR_DISTINCT(DICallSiteParam,
+                        (Context, Record[1], getMDOrNull(Record[2]),
+                         getMDOrNull(Record[3]))),
+        NextMetadataNo);
+    NextMetadataNo++;
+    break;
+  }
   case bitc::METADATA_LEXICAL_BLOCK: {
     if (Record.size() != 5)
       return error("Invalid record");
 
     IsDistinct = Record[0];
     MetadataList.assignValue(
         GET_OR_DISTINCT(DILexicalBlock,
                         (Context, getMDOrNull(Record[1]),

lib/Bitcode/Writer/BitcodeWriter.cpp

void writeDISubroutineType(const DISubroutineType *N,
                              SmallVectorImpl<uint64_t> &Record,
                              unsigned Abbrev);
   void writeDIFile(const DIFile *N, SmallVectorImpl<uint64_t> &Record,
                    unsigned Abbrev);
   void writeDICompileUnit(const DICompileUnit *N,
                           SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
   void writeDISubprogram(const DISubprogram *N,
                          SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
+  void writeDICallSite(const DICallSite *N,
+                       SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
+  void writeDICallSiteParam(const DICallSiteParam *N,
+                            SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
   void writeDILexicalBlock(const DILexicalBlock *N,
                            SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
   void writeDILexicalBlockFile(const DILexicalBlockFile *N,
                                SmallVectorImpl<uint64_t> &Record,
                                unsigned Abbrev);
   void writeDINamespace(const DINamespace *N, SmallVectorImpl<uint64_t> &Record,
                         unsigned Abbrev);
   void writeDIMacro(const DIMacro *N, SmallVectorImpl<uint64_t> &Record,
void ModuleBitcodeWriter::writeDISubprogram(const DISubprogram *N,
   Record.push_back(VE.getMetadataOrNullID(N->getRetainedNodes().get()));
   Record.push_back(N->getThisAdjustment());
   Record.push_back(VE.getMetadataOrNullID(N->getThrownTypes().get()));
 
   Stream.EmitRecord(bitc::METADATA_SUBPROGRAM, Record, Abbrev);
   Record.clear();
 }
 
+void ModuleBitcodeWriter::writeDICallSite(const DICallSite *N,
+                                          SmallVectorImpl<uint64_t> &Record,
+                                          unsigned Abbrev) {
+  Record.push_back((uint64_t)N->isDistinct());
+  Record.push_back(VE.getMetadataOrNullID(N->getScope()));
+  Record.push_back(VE.getMetadataOrNullID(N->getFile()));
+  Record.push_back(VE.getMetadataOrNullID(N->getRawParams()));
+  Record.push_back(N->getLine());
+  Record.push_back(VE.getMetadataOrNullID(N->getRawCalledSubprogram()));
+
+  Stream.EmitRecord(bitc::METADATA_CALL_SITE, Record, Abbrev);
+  Record.clear();
+}
+
+void ModuleBitcodeWriter::writeDICallSiteParam(const DICallSiteParam *N,
+                                               SmallVectorImpl<uint64_t> &Record,
+                                               unsigned Abbrev) {
+  Record.push_back((uint64_t)N->isDistinct());
+  Record.push_back(N->getArgNo());
+  Record.push_back(VE.getMetadataOrNullID(N->getRawVar()));
+  Record.push_back(VE.getMetadataOrNullID(N->getExpression()));
+
+  Stream.EmitRecord(bitc::METADATA_CALL_SITE_PARAM, Record, Abbrev);
+  Record.clear();
+}
+
 void ModuleBitcodeWriter::writeDILexicalBlock(const DILexicalBlock *N,
                                               SmallVectorImpl<uint64_t> &Record,
                                               unsigned Abbrev) {
   Record.push_back(N->isDistinct());
   Record.push_back(VE.getMetadataOrNullID(N->getScope()));
   Record.push_back(VE.getMetadataOrNullID(N->getFile()));
   Record.push_back(N->getLine());
   Record.push_back(N->getColumn());

lib/IR/AsmWriter.cpp

static void writeDISubprogram(raw_ostream &Out, const DISubprogram *N,
   Printer.printMetadata("unit", N->getRawUnit());
   Printer.printMetadata("templateParams", N->getRawTemplateParams());
   Printer.printMetadata("declaration", N->getRawDeclaration());
   Printer.printMetadata("retainedNodes", N->getRawRetainedNodes());
   Printer.printMetadata("thrownTypes", N->getRawThrownTypes());
   Out << ")";
 }
 
+static void writeDICallSite(raw_ostream &Out, const DICallSite *N,
+                            TypePrinting *TypePrinter, SlotTracker *Machine,
+                            const Module *Context) {
+  Out << "!DICallSite(";
+  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
+  Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
+  Printer.printMetadata("file", N->getRawFile());
+  Printer.printMetadata("parameters", N->getRawParams());
+  Printer.printInt("line", N->getLine());
+  Printer.printMetadata("calledSubprogram", N->getRawCalledSubprogram());
+  Out << ")";
+}
+
+static void writeDICallSiteParam(raw_ostream &Out, const DICallSiteParam *N,
+                                 TypePrinting *TypePrinter,
+                                 SlotTracker *Machine,
+                                 const Module *Context) {
+  Out << "!DICallSiteParam(";
+  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
+  Printer.printInt("argno", N->getArgNo());
+  if (DILocalVariable *DIVar = N->getVar())
+    Printer.printMetadata("variable", DIVar);
+  Printer.printMetadata("expr", N->getRawExpression());
+  Out << ")";
+}
+
 static void writeDILexicalBlock(raw_ostream &Out, const DILexicalBlock *N,
                                 TypePrinting *TypePrinter, SlotTracker *Machine,
                                 const Module *Context) {
   Out << "!DILexicalBlock(";
   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
   Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
   Printer.printMetadata("file", N->getRawFile());
   Printer.printInt("line", N->getLine());

lib/IR/DebugInfoMetadata.cpp

bool DISubprogram::describes(const Function *F) const {
   if (F->getSubprogram() == this)
     return true;
   StringRef Name = getLinkageName();
   if (Name.empty())
     Name = getName();
   return F->getName() == Name;
 }
 
+DICallSite *DICallSite::getImpl(LLVMContext &Context, Metadata *Scope,
+                                Metadata *File, Metadata *Params,
+                                unsigned Line, Metadata* CalledSubprogram,
+                                StorageType Storage,
+                                bool ShouldCreate) {
+  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);
+}
+
+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);
+}
+
 DILexicalBlock *DILexicalBlock::getImpl(LLVMContext &Context, Metadata *Scope,
                                         Metadata *File, unsigned Line,
                                         unsigned Column, StorageType Storage,
                                         bool ShouldCreate) {
   // Fixup column.
   adjustColumn(Column);
 
   assert(Scope && "Expected scope");

lib/IR/LLVMContextImpl.h

return Scope == RHS->getRawScope() && File == RHS->getRawFile() &&
            Discriminator == RHS->getDiscriminator();
   }
 
   unsigned getHashValue() const {
     return hash_combine(Scope, File, Discriminator);
   }
 };
 
+template <> struct MDNodeKeyImpl<DICallSite> {
+  unsigned Line;
+  Metadata *Scope;
+  Metadata *File;
+  Metadata *Params;
+  Metadata *CalledSubprogram;
+
+  MDNodeKeyImpl(unsigned Line, Metadata *Scope, Metadata *File,
+                Metadata *Params, Metadata *CalledSubprogram)
+      : Line(Line), Scope(Scope), File(File), Params(Params),
+        CalledSubprogram(CalledSubprogram) {}
+  MDNodeKeyImpl(const DICallSite *N)
+      : Line(N->getLine()), Scope(N->getRawScope()), File(N->getRawFile()),
+        Params(N->getRawParams()),
+        CalledSubprogram(N->getRawCalledSubprogram()) {}
+
+  bool isKeyOf(const DICallSite *RHS) const {
+    return Line == RHS->getLine() && Scope == RHS->getRawScope() &&
+           File == RHS->getRawFile() && Params == RHS->getRawParams() &&
+           CalledSubprogram == RHS->getRawCalledSubprogram();
+  }
+
+  unsigned getHashValue() const { return hash_combine(Scope, File, Line); }
+};
+
+template <> struct MDNodeKeyImpl<DICallSiteParam> {
+  unsigned ArgNo;
+  Metadata *Var;
+  Metadata *Expr;
+
+  MDNodeKeyImpl(unsigned ArgNo, Metadata *Var, Metadata *Expr)
+      : ArgNo(ArgNo), Var(Var), Expr(Expr) {}
+  MDNodeKeyImpl(const DICallSiteParam *N)
+      : ArgNo(N->getArgNo()), Var(N->getRawVar()), Expr(N->getRawExpression()) {
+  }
+
+  // FIXME : CHEK PARENT NODES OF THIS NODE??
+  bool isKeyOf(const DICallSiteParam *RHS) const {
+    return Var == RHS->getRawVar() && Expr == RHS->getRawExpression() &&
+           ArgNo == RHS->getArgNo();
+  }
+
+  unsigned getHashValue() const { return hash_combine(ArgNo, Var, Expr); }
+};
+
 template <> struct MDNodeKeyImpl<DINamespace> {
   Metadata *Scope;
   MDString *Name;
   bool ExportSymbols;
 
   MDNodeKeyImpl(Metadata *Scope, MDString *Name, bool ExportSymbols)
       : Scope(Scope), Name(Name), ExportSymbols(ExportSymbols) {}
   MDNodeKeyImpl(const DINamespace *N)

lib/IR/Verifier.cpp

for (Metadata *Op : ThrownTypes->operands())
                Op);
   }
 
   if (N.areAllCallsDescribed())
     AssertDI(N.isDefinition(),
              "DIFlagAllCallsDescribed must be attached to a definition");
 }
 
+void Verifier::visitDICallSite(const DICallSite &N) {
+  if (auto *S = N.getRawScope())
+    AssertDI(isa<DIScope>(S), "invalid scope", &N, S);
+  if (auto *F = N.getRawFile())
+    AssertDI(isa<DIFile>(F), "invalid file", &N, F);
+
+  if (auto *RawParams = N.getRawParams()) {
+    auto *Params = dyn_cast<MDTuple>(RawParams);
+    AssertDI(Params, "invalid variable list", &N, RawParams);
+    for (Metadata *Op : Params->operands()) {
+      AssertDI(Op && isa<DICallSiteParam>(Op), "invalid local variable", &N,
+               Params, Op);
+    }
+  }
+
+  AssertDI(N.getTag() == dwarf::DW_TAG_GNU_call_site, "invalid tag", &N);
+  AssertDI(N.getRawScope() && isa<DILocalScope>(N.getRawScope()),
+           "callsite requires a valid scope", &N, N.getRawScope());
+}
+
+void Verifier::visitDICallSiteParam(const DICallSiteParam &N) {
+  AssertDI(N.getTag() == dwarf::DW_TAG_GNU_call_site_parameter, "invalid tag",
+           &N);
+  AssertDI(N.getRawVar() || N.getRawExpression(),
+           "call-parameter requires a valid variable metadat or expression",
+           &N);
+}
+
 void Verifier::visitDILexicalBlockBase(const DILexicalBlockBase &N) {
   AssertDI(N.getTag() == dwarf::DW_TAG_lexical_block, "invalid tag", &N);
   AssertDI(N.getRawScope() && isa<DILocalScope>(N.getRawScope()),
            "invalid local scope", &N, N.getRawScope());
   if (auto *SP = dyn_cast<DISubprogram>(N.getRawScope()))
     AssertDI(SP->isDefinition(), "scope points into the type hierarchy", &N);
 }