reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

   40 struct DenseMapPair : public std::pair<KeyT, ValueT> {
   43   KeyT &getFirst() { return std::pair<KeyT, ValueT>::first; }
   44   const KeyT &getFirst() const { return std::pair<KeyT, ValueT>::first; }
   65   using key_type = KeyT;
   69   using iterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT>;
   71       DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT, true>;
  145   size_type count(const_arg_type_t<KeyT> Val) const {
  150   iterator find(const_arg_type_t<KeyT> Val) {
  156   const_iterator find(const_arg_type_t<KeyT> Val) const {
  185   ValueT lookup(const_arg_type_t<KeyT> Val) const {
  195   std::pair<iterator, bool> insert(const std::pair<KeyT, ValueT> &KV) {
  202   std::pair<iterator, bool> insert(std::pair<KeyT, ValueT> &&KV) {
  210   std::pair<iterator, bool> try_emplace(KeyT &&Key, Ts &&... Args) {
  229   std::pair<iterator, bool> try_emplace(const KeyT &Key, Ts &&... Args) {
  249   std::pair<iterator, bool> insert_as(std::pair<KeyT, ValueT> &&KV,
  272   bool erase(const KeyT &Val) {
  291   value_type& FindAndConstruct(const KeyT &Key) {
  299   ValueT &operator[](const KeyT &Key) {
  303   value_type& FindAndConstruct(KeyT &&Key) {
  311   ValueT &operator[](KeyT &&Key) {
  334     const KeyT EmptyKey = getEmptyKey(), TombstoneKey = getTombstoneKey();
  339       P->getFirst().~KeyT();
  349     const KeyT EmptyKey = getEmptyKey();
  351       ::new (&B->getFirst()) KeyT(EmptyKey);
  369     const KeyT EmptyKey = getEmptyKey();
  370     const KeyT TombstoneKey = getTombstoneKey();
  386       B->getFirst().~KeyT();
  392       const DenseMapBase<OtherBaseT, KeyT, ValueT, KeyInfoT, BucketT> &other) {
  414   static unsigned getHashValue(const KeyT &Val) {
  419   static unsigned getHashValue(const LookupKeyT &Val) {
  423   static const KeyT getEmptyKey() {
  429   static const KeyT getTombstoneKey() {
  437     if (shouldReverseIterate<KeyT>()) {
  447     if (shouldReverseIterate<KeyT>()) {
  515   BucketT *InsertIntoBucket(BucketT *TheBucket, KeyArg &&Key,
  525   BucketT *InsertIntoBucketWithLookup(BucketT *TheBucket, KeyT &&Key,
  535   BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
  535   BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
  566     const KeyT EmptyKey = getEmptyKey();
  578   bool LookupBucketFor(const LookupKeyT &Val,
  590     const KeyT EmptyKey = getEmptyKey();
  591     const KeyT TombstoneKey = getTombstoneKey();
  629   bool LookupBucketFor(const LookupKeyT &Val, BucketT *&FoundBucket) {
  684 class DenseMap : public DenseMapBase<DenseMap<KeyT, ValueT, KeyInfoT, BucketT>,
  685                                      KeyT, ValueT, KeyInfoT, BucketT> {
  690   using BaseT = DenseMapBase<DenseMap, KeyT, ValueT, KeyInfoT, BucketT>;
 1163   using ConstIterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, true>;
 1186     if (shouldReverseIterate<KeyT>()) {
 1199       const DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, IsConstSrc> &I)
 1210     if (shouldReverseIterate<KeyT>())
 1249     const KeyT Empty = KeyInfoT::getEmptyKey();
 1250     const KeyT Tombstone = KeyInfoT::getTombstoneKey();
 1259     const KeyT Empty = KeyInfoT::getEmptyKey();
 1260     const KeyT Tombstone = KeyInfoT::getTombstoneKey();

  121   support::little_t<StreamType> Type;
  254   static minidump::StreamType getEmptyKey() { return minidump::StreamType(-1); }
  256   static minidump::StreamType getTombstoneKey() {
  260   static unsigned getHashValue(minidump::StreamType Val) {
  264   static bool isEqual(minidump::StreamType LHS, minidump::StreamType RHS) {
  264   static bool isEqual(minidump::StreamType LHS, minidump::StreamType RHS) {

   45   Optional<ArrayRef<uint8_t>> getRawStream(minidump::StreamType Type) const;
   63     return getStream<minidump::SystemInfo>(minidump::StreamType::SystemInfo);
   72     return getListStream<minidump::Module>(minidump::StreamType::ModuleList);
   81     return getListStream<minidump::Thread>(minidump::StreamType::ThreadList);
   90         minidump::StreamType::Exception);
  102         minidump::StreamType::MemoryList);
  166                DenseMap<minidump::StreamType, std::size_t> StreamMap)
  177   Expected<const T &> getStream(minidump::StreamType Stream) const;
  182   Expected<ArrayRef<T>> getListStream(minidump::StreamType Stream) const;
  186   DenseMap<minidump::StreamType, std::size_t> StreamMap;
  190 Expected<const T &> MinidumpFile::getStream(minidump::StreamType Type) const {

   39   Stream(StreamKind Kind, minidump::StreamType Type) : Kind(Kind), Type(Type) {}
   43   const minidump::StreamType Type;
   46   static StreamKind getKind(minidump::StreamType Type);
   49   static std::unique_ptr<Stream> create(minidump::StreamType Type);
   75   static constexpr minidump::StreamType Type = minidump::StreamType::ModuleList;
   75   static constexpr minidump::StreamType Type = minidump::StreamType::ModuleList;
   86   static constexpr minidump::StreamType Type = minidump::StreamType::ThreadList;
   86   static constexpr minidump::StreamType Type = minidump::StreamType::ThreadList;
   96   static constexpr minidump::StreamType Type = minidump::StreamType::MemoryList;
   96   static constexpr minidump::StreamType Type = minidump::StreamType::MemoryList;
  113       : Stream(StreamKind::Exception, minidump::StreamType::Exception),
  118       : Stream(StreamKind::Exception, minidump::StreamType::Exception),
  133                minidump::StreamType::MemoryInfoList) {}
  138                minidump::StreamType::MemoryInfoList),
  152   RawContentStream(minidump::StreamType Type, ArrayRef<uint8_t> Content = {})
  167       : Stream(StreamKind::SystemInfo, minidump::StreamType::SystemInfo) {
  173       : Stream(StreamKind::SystemInfo, minidump::StreamType::SystemInfo),
  189   TextContentStream(minidump::StreamType Type, StringRef Text = {})

   39  enum { value = alignment == 0 ? alignof(T) : alignment };
   51 inline value_type byte_swap(value_type value, endianness endian) {
   51 inline value_type byte_swap(value_type value, endianness endian) {
   65 inline value_type read(const void *memory, endianness endian) {
   66   value_type ret;
   71          sizeof(value_type));
   72   return byte_swap<value_type>(ret, endian);
   78 inline value_type read(const void *memory) {
   79   return read<value_type, alignment>(memory, endian);
   99 inline void write(void *memory, value_type value, endianness endian) {
  100   value = byte_swap<value_type>(value, endian);
  103          &value, sizeof(value_type));
  109 inline void write(void *memory, value_type value) {
  110   write<value_type, alignment>(memory, value, endian);
  209   using value_type = ValueType;

  146 inline typename std::enable_if<std::is_enum<T>::value, T>::type
  146 inline typename std::enable_if<std::is_enum<T>::value, T>::type
  147 getSwappedBytes(T C) {
  153 inline void swapByteOrder(T &Value) {

  313   using Signature_enumeration = void (*)(class IO&, T&);
  322     (sizeof(test<ScalarEnumerationTraits<T>>(nullptr)) == 1);
  329   using Signature_bitset = void (*)(class IO&, T&);
  337   static bool const value = (sizeof(test<ScalarBitSetTraits<T>>(nullptr)) == 1);
  344   using Signature_input = StringRef (*)(StringRef, void*, T&);
  345   using Signature_output = void (*)(const T&, void*, raw_ostream&);
  357       (sizeof(test<ScalarTraits<T>>(nullptr, nullptr, nullptr)) == 1);
  364   using Signature_input = StringRef (*)(StringRef, void *, T &);
  365   using Signature_output = void (*)(const T &, void *, raw_ostream &);
  375       (sizeof(test<BlockScalarTraits<T>>(nullptr, nullptr)) == 1);
  380   using Signature_input = StringRef (*)(StringRef, StringRef, void *, T &);
  381   using Signature_output = void (*)(const T &, void *, raw_ostream &,
  383   using Signature_mustQuote = QuotingType (*)(const T &, StringRef);
  393       (sizeof(test<TaggedScalarTraits<T>>(nullptr, nullptr, nullptr)) == 1);
  412   using Signature_mapping = void (*)(class IO &, T &);
  419   static bool const value = (sizeof(test<MappingTraits<T>>(nullptr)) == 1);
  438   using Signature_validate = StringRef (*)(class IO &, T &);
  445   static bool const value = (sizeof(test<MappingTraits<T>>(nullptr)) == 1);
  452   using Signature_size = size_t (*)(class IO&, T&);
  460   static bool const value =  (sizeof(test<SequenceTraits<T>>(nullptr)) == 1);
  467   using Signature_input = void (*)(IO &io, StringRef key, T &v);
  476       (sizeof(test<CustomMappingTraits<T>>(nullptr)) == 1);
  516   using Signature_size = size_t (*)(class IO &, T &);
  524   static bool const value = (sizeof(test<DocumentListTraits<T>>(nullptr))==1);
  528   using Signature_getKind = NodeKind (*)(const T &);
  535   static bool const value = (sizeof(test<PolymorphicTraits<T>>(nullptr)) == 1);
  793   void enumCase(T &Val, const char* Str, const T ConstVal) {
  793   void enumCase(T &Val, const char* Str, const T ConstVal) {
  801   void enumCase(T &Val, const char* Str, const uint32_t ConstVal) {
  808   void enumFallback(T &Val) {
  849   template <typename T> void mapRequired(const char *Key, T &Val) {
  941   void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
  968 typename std::enable_if<has_ScalarEnumerationTraits<T>::value, void>::type
  969 yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
  971   ScalarEnumerationTraits<T>::enumeration(io, Val);

   65   using type = const T &;

   18 MinidumpFile::getRawStream(minidump::StreamType Type) const {
   58   Optional<ArrayRef<uint8_t>> Stream = getRawStream(StreamType::MemoryInfoList);
   75 Expected<ArrayRef<T>> MinidumpFile::getListStream(StreamType Type) const {
  128   DenseMap<StreamType, std::size_t> StreamMap;
  130     StreamType Type = StreamDescriptor.value().Type;
  138     if (Type == StreamType::Unused && Loc.DataSize == 0) {
  144     if (Type == DenseMapInfo<StreamType>::getEmptyKey() ||
  145         Type == DenseMapInfo<StreamType>::getTombstoneKey())

   70 Stream::StreamKind Stream::getKind(StreamType Type) {
   72   case StreamType::Exception:
   74   case StreamType::MemoryInfoList:
   76   case StreamType::MemoryList:
   78   case StreamType::ModuleList:
   80   case StreamType::SystemInfo:
   82   case StreamType::LinuxCPUInfo:
   83   case StreamType::LinuxProcStatus:
   84   case StreamType::LinuxLSBRelease:
   85   case StreamType::LinuxCMDLine:
   86   case StreamType::LinuxMaps:
   87   case StreamType::LinuxProcStat:
   88   case StreamType::LinuxProcUptime:
   90   case StreamType::ThreadList:
   97 std::unique_ptr<Stream> Stream::create(StreamType Type) {
  156                                                             StreamType &Type) {
  401   StreamType Type;

   46 llvm::ArrayRef<uint8_t> MinidumpParser::GetStream(StreamType stream_type) {
  227   llvm::ArrayRef<uint8_t> data = GetStream(StreamType::MiscInfo);
  236   llvm::ArrayRef<uint8_t> data = GetStream(StreamType::LinuxProcStatus);
  330   llvm::ArrayRef<uint8_t> data64 = GetStream(StreamType::Memory64List);
  416   auto data = parser.GetStream(StreamType::LinuxMaps);
  495       parser.GetStream(StreamType::Memory64List);
  548 MinidumpParser::GetStreamTypeAsString(StreamType stream_type) {

   57   llvm::ArrayRef<uint8_t> GetStream(StreamType stream_type);
   95   static llvm::StringRef GetStreamTypeAsString(StreamType stream_type);

  808       DumpTextStream(StreamType::LinuxCPUInfo, "/proc/cpuinfo");
  810       DumpTextStream(StreamType::LinuxProcStatus, "/proc/PID/status");
  812       DumpTextStream(StreamType::LinuxLSBRelease, "/etc/lsb-release");
  814       DumpTextStream(StreamType::LinuxCMDLine, "/proc/PID/cmdline");
  816       DumpTextStream(StreamType::LinuxEnviron, "/proc/PID/environ");
  818       DumpBinaryStream(StreamType::LinuxAuxv, "/proc/PID/auxv");
  820       DumpTextStream(StreamType::LinuxMaps, "/proc/PID/maps");
  822       DumpTextStream(StreamType::LinuxProcStat, "/proc/PID/stat");
  824       DumpTextStream(StreamType::LinuxProcUptime, "uptime");
  826       DumpTextStream(StreamType::LinuxProcFD, "/proc/PID/fd");
  828       DumpTextStream(StreamType::FacebookAppCustomData,
  831       auto bytes = minidump.GetStream(StreamType::FacebookBuildID);
  843       DumpTextStream(StreamType::FacebookAppVersionName,
  846       DumpTextStream(StreamType::FacebookJavaStack,
  849       DumpTextStream(StreamType::FacebookDalvikInfo,
  852       DumpBinaryStream(StreamType::FacebookUnwindSymbols,
  855       DumpTextStream(StreamType::FacebookDumpErrorLog,
  858       DumpTextStream(StreamType::FacebookAppStateLog,
  861       DumpTextStream(StreamType::FacebookAbortReason,
  864       DumpTextStream(StreamType::FacebookThreadName,
  867       DumpTextStream(StreamType::FacebookLogcat,

   72     constexpr _Tp&&
   83     constexpr _Tp&&
   98     move(_Tp&& __t) noexcept

  209     : private __pair_base<_T1, _T2>
  211       typedef _T1 first_type;    /// @c first_type is the first bound type
  214       _T1 first;                 /// @c first is a copy of the first object
  252       using _PCCP = _PCC<true, _T1, _T2>;
  260       constexpr pair(const _T1& __a, const _T2& __b)
  269       explicit constexpr pair(const _T1& __a, const _T2& __b)
  283 			    _T1, _T2>;
  325        constexpr pair(const _T1& __x, _U2&& __y)
  332        explicit pair(const _T1& __x, _U2&& __y)
  379 		__and_<is_copy_assignable<_T1>,
  390 		__and_<is_move_assignable<_T1>,
  402       typename enable_if<__and_<is_assignable<_T1&, const _U1&>,
  402       typename enable_if<__and_<is_assignable<_T1&, const _U1&>,
  405 	operator=(const pair<_U1, _U2>& __p)
  413       typename enable_if<__and_<is_assignable<_T1&, _U1&&>,
  413       typename enable_if<__and_<is_assignable<_T1&, _U1&&>,
  416 	operator=(pair<_U1, _U2>&& __p)

  824     make_unique(_Args&&... __args)

  215     : public __is_void_helper<typename remove_cv<_Tp>::type>::type
  381     : public __is_pointer_helper<typename remove_cv<_Tp>::type>::type
  581     : public __or_<is_lvalue_reference<_Tp>,
  582                    is_rvalue_reference<_Tp>>::type
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  602                           is_void<_Tp>>>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  762     typename add_rvalue_reference<_Tp>::type declval() noexcept;
  889       typedef decltype(__test<_Tp>(0)) type;
  894     : public __and_<__not_<is_void<_Tp>>,
  895                     __is_default_constructible_impl<_Tp>>
  915     : public __is_default_constructible_atom<_Tp>::type
  921     : public __is_default_constructible_safe<_Tp>::type
 1286     : public is_assignable<_Tp&, const _Tp&>
 1286     : public is_assignable<_Tp&, const _Tp&>
 1292     : public __is_copy_assignable_impl<_Tp>
 1304     : public is_assignable<_Tp&, _Tp&&>
 1304     : public is_assignable<_Tp&, _Tp&&>
 1310     : public __is_move_assignable_impl<_Tp>
 1377     static void __helper(const _Tp&);
 1380     static true_type __test(const _Tp&,
 1381                             decltype(__helper<const _Tp&>({}))* = 0);
 1390     typedef decltype(__test(declval<_Tp>())) type;
 1395       : public __is_implicitly_default_constructible_impl<_Tp>::type
 1400       : public __and_<is_default_constructible<_Tp>,
 1401                       __is_implicitly_default_constructible_safe<_Tp>>
 1554     { typedef _Tp     type; };
 1563     { typedef _Tp     type; };
 1574       remove_const<typename remove_volatile<_Tp>::type>::type     type;
 1633     { typedef _Tp   type; };
 1659     { typedef _Tp&&   type; };
 1664     : public __add_rvalue_reference_helper<_Tp>
 2157     { typedef _Tp type; };

  140   static void PrintValue(const T& value, ::std::ostream* os) {
  205     ::std::basic_ostream<Char, CharTraits>& os, const T& x) {
  206   TypeWithoutFormatter<T,
  207       (internal::IsAProtocolMessage<T>::value ? kProtobuf :
  208        internal::ImplicitlyConvertible<const T&, internal::BiggestInt>::value ?
  223 void DefaultPrintNonContainerTo(const T& value, ::std::ostream* os) {
  276   static ::std::string Format(const ToPrint& value) {
  351     const T1& value, const T2& /* other_operand */) {
  351     const T1& value, const T2& /* other_operand */) {
  352   return FormatForComparison<T1, T2>::Format(value);
  352   return FormatForComparison<T1, T2>::Format(value);
  366 void UniversalPrint(const T& value, ::std::ostream* os);
  373                     const C& container, ::std::ostream* os) {
  439                     const T& value, ::std::ostream* os) {
  455 void PrintTo(const T& value, ::std::ostream* os) {
  478   DefaultPrintTo(IsContainerTest<T>(0), is_pointer<T>(), value, os);
  699   static void Print(const T& value, ::std::ostream* os) {
  784   static void Print(const T& value, ::std::ostream* os) {
  856   typedef T T1;
  983   internal::UniversalTersePrinter<T>::Print(value, &ss);

 1377                                    const T1& lhs, const T2& rhs) {
 1389                             const T1& lhs,
 1419                                  const T1& lhs,

   29   static const T& printable(const T& V) { return V; }
   29   static const T& printable(const T& V) { return V; }
   35 auto printable(const T &V) -> decltype(StreamSwitch<T>::printable(V)) {
   35 auto printable(const T &V) -> decltype(StreamSwitch<T>::printable(V)) {
   37   return StreamSwitch<T>::printable(V);

   94 ::std::string PrintToString(const T& value);