llvm-profdata: Reduce memory usage by using Error callback rather than member

[dblaikie]

Summary

Reduces llvm-profdata memory usage on a large profile from 7.8GB to 5.1GB.

This also allows all the errors/warnings to be printed rather than only
the first.

[dblaikie]

Improve description

[davidxl]

It feels weird that the error handling is the first parameter of the interfaces. Also is it possible to provide a default error handling ?

tools/llvm-profdata/llvm-profdata.cpp

164

creating a named lambda is more readable IMO.

[dblaikie]

Move warning callback to the last argument.

[davidxl]

include/llvm/ProfileData/InstrProf.h

585

It is better to get rid of the default weight and move Warn to be the last here.

660

can Warn be moved to the last for this one?

729–730

Same here

734–735

Same here

[dblaikie]

Move function_ref to the last arg in the InstrProfRecord APIs

[davidxl]

lgtm

include/llvm/ProfileData/InstrProf.h

ValueData.sort(
           return left.Value < right.Value;
         });
   }
   /// Sort ValueData Descending by Count
   inline void sortByCount();
 
   /// Merge data from another InstrProfValueSiteRecord
   /// Optionally scale merged counts by \p Weight.
-  void merge(SoftInstrProfErrors &SIPE, InstrProfValueSiteRecord &Input,
-             uint64_t Weight = 1);
+  void merge(function_ref<void(instrprof_error)> Warn,
+             InstrProfValueSiteRecord &Input, uint64_t Weight = 1);
   /// Scale up value profile data counts.
-  void scale(SoftInstrProfErrors &SIPE, uint64_t Weight);
+  void scale(function_ref<void(instrprof_error)> Warn, uint64_t Weight);
 };
 
 /// Profiling information for a single function.
 struct InstrProfRecord {
   std::vector<uint64_t> Counts;
-  SoftInstrProfErrors SIPE;
 
   InstrProfRecord() = default;
   InstrProfRecord(std::vector<uint64_t> Counts) : Counts(std::move(Counts)) {}
   InstrProfRecord(InstrProfRecord &&) = default;
   InstrProfRecord(const InstrProfRecord &RHS)
       : Counts(RHS.Counts),
         ValueData(RHS.ValueData
                       ? llvm::make_unique<ValueProfData>(*RHS.ValueData)
struct InstrProfRecord {
 
   /// Add ValueData for ValueKind at value Site.
   void addValueData(uint32_t ValueKind, uint32_t Site,
                     InstrProfValueData *VData, uint32_t N,
                     ValueMapType *ValueMap);
 
   /// Merge the counts in \p Other into this one.
   /// Optionally scale merged counts by \p Weight.
-  void merge(InstrProfRecord &Other, uint64_t Weight = 1);
+  void merge(function_ref<void(instrprof_error)> Warn, InstrProfRecord &Other,
+             uint64_t Weight = 1);
 
   /// Scale up profile counts (including value profile data) by
   /// \p Weight.
-  void scale(uint64_t Weight);
+  void scale(function_ref<void(instrprof_error)> Warn, uint64_t Weight);
 
   /// Sort value profile data (per site) by count.
   void sortValueData() {
     for (uint32_t Kind = IPVK_First; Kind <= IPVK_Last; ++Kind)
       for (auto &SR : getValueSitesForKind(Kind))
         SR.sortByCount();
   }
 
   /// Clear value data entries and edge counters.
   void Clear() {
     Counts.clear();
     clearValueData();
   }
 
   /// Clear value data entries
   void clearValueData() { ValueData = nullptr; }
 
-  /// Get the error contained within the record's soft error counter.
-  Error takeError() { return SIPE.takeError(); }
-
 private:
   struct ValueProfData {
     std::vector<InstrProfValueSiteRecord> IndirectCallSites;
     std::vector<InstrProfValueSiteRecord> MemOPSizes;
   };
   std::unique_ptr<ValueProfData> ValueData;
 
   MutableArrayRef<InstrProfValueSiteRecord>
private:
   }
 
   // Map indirect call target name hash to name string.
   uint64_t remapValue(uint64_t Value, uint32_t ValueKind,
                       ValueMapType *HashKeys);
 
   // Merge Value Profile data from Src record to this record for ValueKind.
   // Scale merged value counts by \p Weight.
-  void mergeValueProfData(uint32_t ValueKind, InstrProfRecord &Src,
+  void mergeValueProfData(function_ref<void(instrprof_error)> Warn,
+                          uint32_t ValueKind, InstrProfRecord &Src,
                           uint64_t Weight);
 
   // Scale up value profile data count.
-  void scaleValueProfData(uint32_t ValueKind, uint64_t Weight);
+  void scaleValueProfData(function_ref<void(instrprof_error)> Warn,
+                          uint32_t ValueKind, uint64_t Weight);
 };
 
 struct NamedInstrProfRecord : InstrProfRecord {
   StringRef Name;
   uint64_t Hash;
 
   NamedInstrProfRecord() = default;
   NamedInstrProfRecord(StringRef Name, uint64_t Hash,

include/llvm/ProfileData/InstrProfWriter.h

 
 public:
   InstrProfWriter(bool Sparse = false);
   ~InstrProfWriter();
 
   /// Add function counts for the given function. If there are already counts
   /// for this function and the hash and number of counts match, each counter is
   /// summed. Optionally scale counts by \p Weight.
-  Error addRecord(NamedInstrProfRecord &&I, uint64_t Weight = 1);
+  void addRecord(function_ref<void(Error)> Warn, NamedInstrProfRecord &&I,
+                 uint64_t Weight = 1);
 
   /// Merge existing function counts from the given writer.
-  Error mergeRecordsFromWriter(InstrProfWriter &&IPW);
+  void mergeRecordsFromWriter(function_ref<void(Error)> Warn,
+                              InstrProfWriter &&IPW);
 
   /// Write the profile to \c OS
   void write(raw_fd_ostream &OS);
 
   /// Write the profile in text format to \c OS
   Error writeText(raw_fd_ostream &OS);
 
   /// Write \c Record in text format to \c OS
return (IsIRLevel == (ProfileKind == PF_IRLevel))
                      instrprof_error::unsupported_version);
   }
 
   // Internal interface for testing purpose only.
   void setValueProfDataEndianness(support::endianness Endianness);
   void setOutputSparse(bool Sparse);
 
 private:
-  Error addRecord(StringRef Name, uint64_t Hash, InstrProfRecord &&I,
-                  uint64_t Weight = 1);
+  void addRecord(function_ref<void(Error)> Warn, StringRef Name, uint64_t Hash,
+                 InstrProfRecord &&I, uint64_t Weight = 1);
   bool shouldEncodeData(const ProfilingData &PD);
   void writeImpl(ProfOStream &OS);
 };
 
 } // end namespace llvm
 
 #endif // LLVM_PROFILEDATA_INSTRPROFWRITER_H

lib/ProfileData/InstrProf.cpp

while (P < EndP) {
 
     while (P < EndP && *P == 0)
       P++;
   }
   Symtab.finalizeSymtab();
   return Error::success();
 }
 
-void InstrProfValueSiteRecord::merge(SoftInstrProfErrors &SIPE,
+void InstrProfValueSiteRecord::merge(function_ref<void(instrprof_error)> Warn,
                                      InstrProfValueSiteRecord &Input,
                                      uint64_t Weight) {
   this->sortByTargetValues();
   Input.sortByTargetValues();
   auto I = ValueData.begin();
   auto IE = ValueData.end();
   for (auto J = Input.ValueData.begin(), JE = Input.ValueData.end(); J != JE;
        ++J) {
     while (I != IE && I->Value < J->Value)
       ++I;
     if (I != IE && I->Value == J->Value) {
       bool Overflowed;
       I->Count = SaturatingMultiplyAdd(J->Count, Weight, I->Count, &Overflowed);
       if (Overflowed)
-        SIPE.addError(instrprof_error::counter_overflow);
+        Warn(instrprof_error::counter_overflow);
       ++I;
       continue;
     }
     ValueData.insert(I, *J);
   }
 }
 
-void InstrProfValueSiteRecord::scale(SoftInstrProfErrors &SIPE,
+void InstrProfValueSiteRecord::scale(function_ref<void(instrprof_error)> Warn,
                                      uint64_t Weight) {
   for (auto I = ValueData.begin(), IE = ValueData.end(); I != IE; ++I) {
     bool Overflowed;
     I->Count = SaturatingMultiply(I->Count, Weight, &Overflowed);
     if (Overflowed)
-      SIPE.addError(instrprof_error::counter_overflow);
+      Warn(instrprof_error::counter_overflow);
   }
 }
 
 // Merge Value Profile data from Src record to this record for ValueKind.
 // Scale merged value counts by \p Weight.
-void InstrProfRecord::mergeValueProfData(uint32_t ValueKind,
-                                         InstrProfRecord &Src,
-                                         uint64_t Weight) {
+void InstrProfRecord::mergeValueProfData(
+    function_ref<void(instrprof_error)> Warn, uint32_t ValueKind,
+    InstrProfRecord &Src, uint64_t Weight) {
   uint32_t ThisNumValueSites = getNumValueSites(ValueKind);
   uint32_t OtherNumValueSites = Src.getNumValueSites(ValueKind);
   if (ThisNumValueSites != OtherNumValueSites) {
-    SIPE.addError(instrprof_error::value_site_count_mismatch);
+    Warn(instrprof_error::value_site_count_mismatch);
     return;
   }
   if (!ThisNumValueSites)
     return;
   std::vector<InstrProfValueSiteRecord> &ThisSiteRecords =
       getOrCreateValueSitesForKind(ValueKind);
   MutableArrayRef<InstrProfValueSiteRecord> OtherSiteRecords =
       Src.getValueSitesForKind(ValueKind);
   for (uint32_t I = 0; I < ThisNumValueSites; I++)
-    ThisSiteRecords[I].merge(SIPE, OtherSiteRecords[I], Weight);
+    ThisSiteRecords[I].merge(Warn, OtherSiteRecords[I], Weight);
 }
 
-void InstrProfRecord::merge(InstrProfRecord &Other, uint64_t Weight) {
+void InstrProfRecord::merge(function_ref<void(instrprof_error)> Warn,
+                            InstrProfRecord &Other, uint64_t Weight) {
   // If the number of counters doesn't match we either have bad data
   // or a hash collision.
   if (Counts.size() != Other.Counts.size()) {
-    SIPE.addError(instrprof_error::count_mismatch);
+    Warn(instrprof_error::count_mismatch);
     return;
   }
 
   for (size_t I = 0, E = Other.Counts.size(); I < E; ++I) {
     bool Overflowed;
     Counts[I] =
         SaturatingMultiplyAdd(Other.Counts[I], Weight, Counts[I], &Overflowed);
     if (Overflowed)
-      SIPE.addError(instrprof_error::counter_overflow);
+      Warn(instrprof_error::counter_overflow);
   }
 
   for (uint32_t Kind = IPVK_First; Kind <= IPVK_Last; ++Kind)
-    mergeValueProfData(Kind, Other, Weight);
+    mergeValueProfData(Warn, Kind, Other, Weight);
 }
 
-void InstrProfRecord::scaleValueProfData(uint32_t ValueKind, uint64_t Weight) {
+void InstrProfRecord::scaleValueProfData(
+    function_ref<void(instrprof_error)> Warn, uint32_t ValueKind,
+    uint64_t Weight) {
   for (auto &R : getValueSitesForKind(ValueKind))
-    R.scale(SIPE, Weight);
+    R.scale(Warn, Weight);
 }
 
-void InstrProfRecord::scale(uint64_t Weight) {
+void InstrProfRecord::scale(function_ref<void(instrprof_error)> Warn,
+                            uint64_t Weight) {
   for (auto &Count : this->Counts) {
     bool Overflowed;
     Count = SaturatingMultiply(Count, Weight, &Overflowed);
     if (Overflowed)
-      SIPE.addError(instrprof_error::counter_overflow);
+      Warn(instrprof_error::counter_overflow);
   }
   for (uint32_t Kind = IPVK_First; Kind <= IPVK_Last; ++Kind)
-    scaleValueProfData(Kind, Weight);
+    scaleValueProfData(Warn, Kind, Weight);
 }
 
 // Map indirect call target name hash to name string.
 uint64_t InstrProfRecord::remapValue(uint64_t Value, uint32_t ValueKind,
                                      ValueMapType *ValueMap) {
   if (!ValueMap)
     return Value;
   switch (ValueKind) {

lib/ProfileData/InstrProfWriter.cpp

void InstrProfWriter::setValueProfDataEndianness(
     support::endianness Endianness) {
   InfoObj->ValueProfDataEndianness = Endianness;
 }
 
 void InstrProfWriter::setOutputSparse(bool Sparse) {
   this->Sparse = Sparse;
 }
 
-Error InstrProfWriter::addRecord(NamedInstrProfRecord &&I, uint64_t Weight) {
+void InstrProfWriter::addRecord(function_ref<void(Error)> Warn,
+                                NamedInstrProfRecord &&I, uint64_t Weight) {
   auto Name = I.Name;
   auto Hash = I.Hash;
-  return addRecord(Name, Hash, std::move(I), Weight);
+  addRecord(Warn, Name, Hash, std::move(I), Weight);
 }
 
-Error InstrProfWriter::addRecord(StringRef Name, uint64_t Hash,
-                                 InstrProfRecord &&I, uint64_t Weight) {
+void InstrProfWriter::addRecord(function_ref<void(Error)> Warn, StringRef Name,
+                                uint64_t Hash, InstrProfRecord &&I,
+                                uint64_t Weight) {
   auto &ProfileDataMap = FunctionData[Name];
 
   bool NewFunc;
   ProfilingData::iterator Where;
   std::tie(Where, NewFunc) =
       ProfileDataMap.insert(std::make_pair(Hash, InstrProfRecord()));
   InstrProfRecord &Dest = Where->second;
 
+  auto MapWarn = [&](instrprof_error E) {
+    Warn(make_error<InstrProfError>(E));
+  };
+
   if (NewFunc) {
     // We've never seen a function with this name and hash, add it.
     Dest = std::move(I);
     if (Weight > 1)
-      Dest.scale(Weight);
+      Dest.scale(MapWarn, Weight);
   } else {
     // We're updating a function we've seen before.
-    Dest.merge(I, Weight);
+    Dest.merge(MapWarn, I, Weight);
   }
 
   Dest.sortValueData();
-
-  return Dest.takeError();
 }
 
-Error InstrProfWriter::mergeRecordsFromWriter(InstrProfWriter &&IPW) {
+void InstrProfWriter::mergeRecordsFromWriter(function_ref<void(Error)> Warn,
+                                             InstrProfWriter &&IPW) {
   for (auto &I : IPW.FunctionData)
     for (auto &Func : I.getValue())
-      if (Error E = addRecord(I.getKey(), Func.first, std::move(Func.second)))
-        return E;
-  return Error::success();
+      addRecord(Warn, I.getKey(), Func.first, std::move(Func.second));
 }
 
 bool InstrProfWriter::shouldEncodeData(const ProfilingData &PD) {
   if (!Sparse)
     return true;
   for (const auto &Func : PD) {
     const InstrProfRecord &IPR = Func.second;
     if (llvm::any_of(IPR.Counts, [](uint64_t Count) { return Count > 0; }))

tools/llvm-profdata/llvm-profdata.cpp

if (WC->Writer.setIsIRLevelProfile(IsIRProfile)) {
     WC->Err = make_error<StringError>(
         "Merge IR generated profile with Clang generated profile.",
         std::error_code());
     return;
   }
 
   for (auto &I : *Reader) {
     const StringRef FuncName = I.Name;
-    if (Error E = WC->Writer.addRecord(std::move(I), Input.Weight)) {
+    bool Reported = false;
+    WC->Writer.addRecord(
+        [&](Error E) {
+          if (Reported) {
+            consumeError(std::move(E));
+            return;
+          }
+          Reported = true;
           // Only show hint the first time an error occurs.
           instrprof_error IPE = InstrProfError::take(std::move(E));
           std::unique_lock<std::mutex> ErrGuard{WC->ErrLock};
           bool firstTime = WC->WriterErrorCodes.insert(IPE).second;
-      handleMergeWriterError(make_error<InstrProfError>(IPE), Input.Filename,
-                             FuncName, firstTime);
-    }
+          handleMergeWriterError(make_error<InstrProfError>(IPE),
+                                 Input.Filename, FuncName, firstTime);
+        },
+        std::move(I), Input.Weight);
   }
   if (Reader->hasError())
     WC->Err = Reader->getError();
 }
 
 /// Merge the \p Src writer context into \p Dst.
 static void mergeWriterContexts(WriterContext *Dst, WriterContext *Src) {
-  if (Error E = Dst->Writer.mergeRecordsFromWriter(std::move(Src->Writer)))
+  bool Reported = false;
+  Dst->Writer.mergeRecordsFromWriter(
+      [&](Error E) {
+        if (Reported) {
+          consumeError(std::move(E));
+          return;
+        }
+        Reported = true;
         Dst->Err = std::move(E);
+      },
+      std::move(Src->Writer));
 }
 
 static void mergeInstrProfile(const WeightedFileVector &Inputs,
                               StringRef OutputFilename,
                               ProfileFormat OutputFormat, bool OutputSparse,
                               unsigned NumThreads) {
   if (OutputFilename.compare("-") == 0)
     exitWithError("Cannot write indexed profdata format to stdout.");

unittests/ProfileData/CoverageMappingTest.cpp

TEST_P(CoverageMappingTest, correct_deserialize_for_more_than_two_files) {
   for (unsigned I = 0; I < N; ++I) {
     ASSERT_GT(N, Output.Regions[I].FileID);
     ASSERT_GT(N, Output.Regions[I].LineStart);
     EXPECT_EQ(FileNames[Output.Regions[I].LineStart],
               Output.Filenames[Output.Regions[I].FileID]);
   }
 }
 
+static const auto Err = [](Error E) { FAIL(); };
+
 TEST_P(CoverageMappingTest, load_coverage_for_more_than_two_files) {
-  EXPECT_THAT_ERROR(ProfileWriter.addRecord({"func", 0x1234, {0}}),
-                    Succeeded());
+  ProfileWriter.addRecord(Err, {"func", 0x1234, {0}});
 
   const char *FileNames[] = {"bar", "baz", "foo"};
   static const unsigned N = array_lengthof(FileNames);
 
   startFunction("func", 0x1234);
   for (unsigned I = 0; I < N; ++I)
     // Use LineStart to hold the index of the file name
     // in order to preserve that information during possible sorting of CMRs.
     addCMR(Counter::getCounter(0), FileNames[I], I, 1, I, 1);
 
   EXPECT_THAT_ERROR(loadCoverageMapping(), Succeeded());
 
   for (unsigned I = 0; I < N; ++I) {
     CoverageData Data = LoadedCoverage->getCoverageForFile(FileNames[I]);
     ASSERT_TRUE(!Data.empty());
     EXPECT_EQ(I, Data.begin()->Line);
   }
 }
 
 TEST_P(CoverageMappingTest, load_coverage_with_bogus_function_name) {
-  EXPECT_THAT_ERROR(ProfileWriter.addRecord({"", 0x1234, {10}}), Succeeded());
+  ProfileWriter.addRecord(Err, {"", 0x1234, {10}});
   startFunction("", 0x1234);
   addCMR(Counter::getCounter(0), "foo", 1, 1, 5, 5);
   EXPECT_TRUE(ErrorEquals(coveragemap_error::malformed, loadCoverageMapping()));
 }
 
 TEST_P(CoverageMappingTest, load_coverage_for_several_functions) {
-  EXPECT_THAT_ERROR(ProfileWriter.addRecord({"func1", 0x1234, {10}}),
-                    Succeeded());
-  EXPECT_THAT_ERROR(ProfileWriter.addRecord({"func2", 0x2345, {20}}),
-                    Succeeded());
+  ProfileWriter.addRecord(Err, {"func1", 0x1234, {10}});
+  ProfileWriter.addRecord(Err, {"func2", 0x2345, {20}});
 
   startFunction("func1", 0x1234);
   addCMR(Counter::getCounter(0), "foo", 1, 1, 5, 5);
 
   startFunction("func2", 0x2345);
   addCMR(Counter::getCounter(0), "bar", 2, 2, 6, 6);
 
   EXPECT_THAT_ERROR(loadCoverageMapping(), Succeeded());
TEST_P(CoverageMappingTest, expansion_gets_first_counter) {
   OutputFunctionCoverageData &Output = OutputFunctions.back();
 
   ASSERT_EQ(CounterMappingRegion::ExpansionRegion, Output.Regions[2].Kind);
   ASSERT_EQ(Counter::getCounter(2), Output.Regions[2].Count);
   ASSERT_EQ(3U, Output.Regions[2].LineStart);
 }
 
 TEST_P(CoverageMappingTest, basic_coverage_iteration) {
-  EXPECT_THAT_ERROR(ProfileWriter.addRecord({"func", 0x1234, {30, 20, 10, 0}}),
-                    Succeeded());
+  ProfileWriter.addRecord(Err, {"func", 0x1234, {30, 20, 10, 0}});
 
   startFunction("func", 0x1234);
   addCMR(Counter::getCounter(0), "file1", 1, 1, 9, 9);
   addCMR(Counter::getCounter(1), "file1", 1, 1, 4, 7);
   addCMR(Counter::getCounter(2), "file1", 5, 8, 9, 1);
   addCMR(Counter::getCounter(3), "file1", 10, 10, 11, 11);
   EXPECT_THAT_ERROR(loadCoverageMapping(), Succeeded());
 
TEST_P(CoverageMappingTest, uncovered_function_with_mapping) {
   std::vector<CoverageSegment> Segments(Data.begin(), Data.end());
   ASSERT_EQ(3U, Segments.size());
   ASSERT_EQ(CoverageSegment(1, 1, 0, true),  Segments[0]);
   ASSERT_EQ(CoverageSegment(4, 7, 0, false), Segments[1]);
   ASSERT_EQ(CoverageSegment(9, 9, false),    Segments[2]);
 }
 
 TEST_P(CoverageMappingTest, combine_regions) {
-  EXPECT_THAT_ERROR(ProfileWriter.addRecord({"func", 0x1234, {10, 20, 30}}),
-                    Succeeded());
+  ProfileWriter.addRecord(Err, {"func", 0x1234, {10, 20, 30}});
 
   startFunction("func", 0x1234);
   addCMR(Counter::getCounter(0), "file1", 1, 1, 9, 9);
   addCMR(Counter::getCounter(1), "file1", 3, 3, 4, 4);
   addCMR(Counter::getCounter(2), "file1", 3, 3, 4, 4);
   EXPECT_THAT_ERROR(loadCoverageMapping(), Succeeded());
 
   CoverageData Data = LoadedCoverage->getCoverageForFile("file1");
   std::vector<CoverageSegment> Segments(Data.begin(), Data.end());
   ASSERT_EQ(4U, Segments.size());
   ASSERT_EQ(CoverageSegment(1, 1, 10, true), Segments[0]);
   ASSERT_EQ(CoverageSegment(3, 3, 50, true), Segments[1]);
   ASSERT_EQ(CoverageSegment(4, 4, 10, false), Segments[2]);
   ASSERT_EQ(CoverageSegment(9, 9, false), Segments[3]);
 }
 
 TEST_P(CoverageMappingTest, restore_combined_counter_after_nested_region) {
-  EXPECT_THAT_ERROR(ProfileWriter.addRecord({"func", 0x1234, {10, 20, 40}}),
-                    Succeeded());
+  ProfileWriter.addRecord(Err, {"func", 0x1234, {10, 20, 40}});
 
   startFunction("func", 0x1234);
   addCMR(Counter::getCounter(0), "file1", 1, 1, 9, 9);
   addCMR(Counter::getCounter(1), "file1", 1, 1, 9, 9);
   addCMR(Counter::getCounter(2), "file1", 3, 3, 5, 5);
   EXPECT_THAT_ERROR(loadCoverageMapping(), Succeeded());
 
   CoverageData Data = LoadedCoverage->getCoverageForFile("file1");
   std::vector<CoverageSegment> Segments(Data.begin(), Data.end());
   ASSERT_EQ(4U, Segments.size());
   EXPECT_EQ(CoverageSegment(1, 1, 30, true), Segments[0]);
   EXPECT_EQ(CoverageSegment(3, 3, 40, true), Segments[1]);
   EXPECT_EQ(CoverageSegment(5, 5, 30, false), Segments[2]);
   EXPECT_EQ(CoverageSegment(9, 9, false), Segments[3]);
 }
 
 // If CodeRegions and ExpansionRegions cover the same area,
 // only counts of CodeRegions should be used.
 TEST_P(CoverageMappingTest, dont_combine_expansions) {
-  EXPECT_THAT_ERROR(ProfileWriter.addRecord({"func", 0x1234, {10, 20}}),
-                    Succeeded());
-  EXPECT_THAT_ERROR(ProfileWriter.addRecord({"func", 0x1234, {0, 0}}),
-                    Succeeded());
+  ProfileWriter.addRecord(Err, {"func", 0x1234, {10, 20}});
+  ProfileWriter.addRecord(Err, {"func", 0x1234, {0, 0}});
 
   startFunction("func", 0x1234);
   addCMR(Counter::getCounter(0), "file1", 1, 1, 9, 9);
   addCMR(Counter::getCounter(1), "file1", 3, 3, 4, 4);
   addCMR(Counter::getCounter(1), "include1", 6, 6, 7, 7);
   addExpansionCMR("file1", "include1", 3, 3, 4, 4);
   EXPECT_THAT_ERROR(loadCoverageMapping(), Succeeded());
 
   CoverageData Data = LoadedCoverage->getCoverageForFile("file1");
   std::vector<CoverageSegment> Segments(Data.begin(), Data.end());
   ASSERT_EQ(4U, Segments.size());
   ASSERT_EQ(CoverageSegment(1, 1, 10, true), Segments[0]);
   ASSERT_EQ(CoverageSegment(3, 3, 20, true), Segments[1]);
   ASSERT_EQ(CoverageSegment(4, 4, 10, false), Segments[2]);
   ASSERT_EQ(CoverageSegment(9, 9, false), Segments[3]);
 }
 
 // If an area is covered only by ExpansionRegions, they should be combinated.
 TEST_P(CoverageMappingTest, combine_expansions) {
-  EXPECT_THAT_ERROR(ProfileWriter.addRecord({"func", 0x1234, {2, 3, 7}}),
-                    Succeeded());
+  ProfileWriter.addRecord(Err, {"func", 0x1234, {2, 3, 7}});
 
   startFunction("func", 0x1234);
   addCMR(Counter::getCounter(1), "include1", 1, 1, 1, 10);
   addCMR(Counter::getCounter(2), "include2", 1, 1, 1, 10);
   addCMR(Counter::getCounter(0), "file", 1, 1, 5, 5);
   addExpansionCMR("file", "include1", 3, 1, 3, 5);
   addExpansionCMR("file", "include2", 3, 1, 3, 5);
 
   EXPECT_THAT_ERROR(loadCoverageMapping(), Succeeded());
 
   CoverageData Data = LoadedCoverage->getCoverageForFile("file");
   std::vector<CoverageSegment> Segments(Data.begin(), Data.end());
   ASSERT_EQ(4U, Segments.size());
   EXPECT_EQ(CoverageSegment(1, 1, 2, true), Segments[0]);
   EXPECT_EQ(CoverageSegment(3, 1, 10, true), Segments[1]);
   EXPECT_EQ(CoverageSegment(3, 5, 2, false), Segments[2]);
   EXPECT_EQ(CoverageSegment(5, 5, false), Segments[3]);
 }
 
 TEST_P(CoverageMappingTest, strip_filename_prefix) {
-  EXPECT_THAT_ERROR(ProfileWriter.addRecord({"file1:func", 0x1234, {0}}),
-                    Succeeded());
+  ProfileWriter.addRecord(Err, {"file1:func", 0x1234, {0}});
 
   startFunction("file1:func", 0x1234);
   addCMR(Counter::getCounter(0), "file1", 1, 1, 9, 9);
   EXPECT_THAT_ERROR(loadCoverageMapping(), Succeeded());
 
   std::vector<std::string> Names;
   for (const auto &Func : LoadedCoverage->getCoveredFunctions())
     Names.push_back(Func.Name);
   ASSERT_EQ(1U, Names.size());
   ASSERT_EQ("func", Names[0]);
 }
 
 TEST_P(CoverageMappingTest, strip_unknown_filename_prefix) {
-  EXPECT_THAT_ERROR(ProfileWriter.addRecord({"<unknown>:func", 0x1234, {0}}),
-                    Succeeded());
+  ProfileWriter.addRecord(Err, {"<unknown>:func", 0x1234, {0}});
 
   startFunction("<unknown>:func", 0x1234);
   addCMR(Counter::getCounter(0), "", 1, 1, 9, 9);
   EXPECT_THAT_ERROR(loadCoverageMapping(/*EmitFilenames=*/false), Succeeded());
 
   std::vector<std::string> Names;
   for (const auto &Func : LoadedCoverage->getCoveredFunctions())
     Names.push_back(Func.Name);
   ASSERT_EQ(1U, Names.size());
   ASSERT_EQ("func", Names[0]);
 }
 
 TEST_P(CoverageMappingTest, dont_detect_false_instantiations) {
-  EXPECT_THAT_ERROR(ProfileWriter.addRecord({"foo", 0x1234, {10}}),
-                    Succeeded());
-  EXPECT_THAT_ERROR(ProfileWriter.addRecord({"bar", 0x2345, {20}}),
-                    Succeeded());
+  ProfileWriter.addRecord(Err, {"foo", 0x1234, {10}});
+  ProfileWriter.addRecord(Err, {"bar", 0x2345, {20}});
 
   startFunction("foo", 0x1234);
   addCMR(Counter::getCounter(0), "expanded", 1, 1, 1, 10);
   addExpansionCMR("main", "expanded", 4, 1, 4, 5);
 
   startFunction("bar", 0x2345);
   addCMR(Counter::getCounter(0), "expanded", 1, 1, 1, 10);
   addExpansionCMR("main", "expanded", 9, 1, 9, 5);
 
   EXPECT_THAT_ERROR(loadCoverageMapping(), Succeeded());
 
   std::vector<const FunctionRecord *> Instantiations =
       LoadedCoverage->getInstantiations("expanded");
   ASSERT_TRUE(Instantiations.empty());
 }
 
 TEST_P(CoverageMappingTest, load_coverage_for_expanded_file) {
-  EXPECT_THAT_ERROR(ProfileWriter.addRecord({"func", 0x1234, {10}}),
-                    Succeeded());
+  ProfileWriter.addRecord(Err, {"func", 0x1234, {10}});
 
   startFunction("func", 0x1234);
   addCMR(Counter::getCounter(0), "expanded", 1, 1, 1, 10);
   addExpansionCMR("main", "expanded", 4, 1, 4, 5);
 
   EXPECT_THAT_ERROR(loadCoverageMapping(), Succeeded());
 
   CoverageData Data = LoadedCoverage->getCoverageForFile("expanded");
   std::vector<CoverageSegment> Segments(Data.begin(), Data.end());
   ASSERT_EQ(2U, Segments.size());
   EXPECT_EQ(CoverageSegment(1, 1, 10, true), Segments[0]);
   EXPECT_EQ(CoverageSegment(1, 10, false), Segments[1]);
 }
 
 TEST_P(CoverageMappingTest, skip_duplicate_function_record) {
-  EXPECT_THAT_ERROR(ProfileWriter.addRecord({"func", 0x1234, {1}}),
-                    Succeeded());
+  ProfileWriter.addRecord(Err, {"func", 0x1234, {1}});
 
   startFunction("func", 0x1234);
   addCMR(Counter::getCounter(0), "file1", 1, 1, 9, 9);
 
   startFunction("func", 0x1234);
   addCMR(Counter::getCounter(0), "file1", 1, 1, 9, 9);
 
   EXPECT_THAT_ERROR(loadCoverageMapping(), Succeeded());

unittests/ProfileData/InstrProfTest.cpp

 };
 
 TEST_P(MaybeSparseInstrProfTest, write_and_read_empty_profile) {
   auto Profile = Writer.writeBuffer();
   readProfile(std::move(Profile));
   ASSERT_TRUE(Reader->begin() == Reader->end());
 }
 
+static const auto Err = [](Error E) {
+  consumeError(std::move(E));
+  FAIL();
+};
+
 TEST_P(MaybeSparseInstrProfTest, write_and_read_one_function) {
-  EXPECT_THAT_ERROR(Writer.addRecord({"foo", 0x1234, {1, 2, 3, 4}}),
-                    Succeeded());
+  Writer.addRecord(Err, {"foo", 0x1234, {1, 2, 3, 4}});
   auto Profile = Writer.writeBuffer();
   readProfile(std::move(Profile));
 
   auto I = Reader->begin(), E = Reader->end();
   ASSERT_TRUE(I != E);
   ASSERT_EQ(StringRef("foo"), I->Name);
   ASSERT_EQ(0x1234U, I->Hash);
   ASSERT_EQ(4U, I->Counts.size());
   ASSERT_EQ(1U, I->Counts[0]);
   ASSERT_EQ(2U, I->Counts[1]);
   ASSERT_EQ(3U, I->Counts[2]);
   ASSERT_EQ(4U, I->Counts[3]);
   ASSERT_TRUE(++I == E);
 }
 
 TEST_P(MaybeSparseInstrProfTest, get_instr_prof_record) {
-  EXPECT_THAT_ERROR(Writer.addRecord({"foo", 0x1234, {1, 2}}), Succeeded());
-  EXPECT_THAT_ERROR(Writer.addRecord({"foo", 0x1235, {3, 4}}), Succeeded());
+  Writer.addRecord(Err, {"foo", 0x1234, {1, 2}});
+  Writer.addRecord(Err, {"foo", 0x1235, {3, 4}});
   auto Profile = Writer.writeBuffer();
   readProfile(std::move(Profile));
 
   Expected<InstrProfRecord> R = Reader->getInstrProfRecord("foo", 0x1234);
   EXPECT_THAT_ERROR(R.takeError(), Succeeded());
   ASSERT_EQ(2U, R->Counts.size());
   ASSERT_EQ(1U, R->Counts[0]);
   ASSERT_EQ(2U, R->Counts[1]);
 
   R = Reader->getInstrProfRecord("foo", 0x1235);
   EXPECT_THAT_ERROR(R.takeError(), Succeeded());
   ASSERT_EQ(2U, R->Counts.size());
   ASSERT_EQ(3U, R->Counts[0]);
   ASSERT_EQ(4U, R->Counts[1]);
 
   R = Reader->getInstrProfRecord("foo", 0x5678);
   ASSERT_TRUE(ErrorEquals(instrprof_error::hash_mismatch, R.takeError()));
 
   R = Reader->getInstrProfRecord("bar", 0x1234);
   ASSERT_TRUE(ErrorEquals(instrprof_error::unknown_function, R.takeError()));
 }
 
 TEST_P(MaybeSparseInstrProfTest, get_function_counts) {
-  EXPECT_THAT_ERROR(Writer.addRecord({"foo", 0x1234, {1, 2}}), Succeeded());
-  EXPECT_THAT_ERROR(Writer.addRecord({"foo", 0x1235, {3, 4}}), Succeeded());
+  Writer.addRecord(Err, {"foo", 0x1234, {1, 2}});
+  Writer.addRecord(Err, {"foo", 0x1235, {3, 4}});
   auto Profile = Writer.writeBuffer();
   readProfile(std::move(Profile));
 
   std::vector<uint64_t> Counts;
   EXPECT_THAT_ERROR(Reader->getFunctionCounts("foo", 0x1234, Counts),
                     Succeeded());
   ASSERT_EQ(2U, Counts.size());
   ASSERT_EQ(1U, Counts[0]);
TEST_P(MaybeSparseInstrProfTest, get_function_counts) {
   ASSERT_TRUE(ErrorEquals(instrprof_error::hash_mismatch, std::move(E1)));
 
   Error E2 = Reader->getFunctionCounts("bar", 0x1234, Counts);
   ASSERT_TRUE(ErrorEquals(instrprof_error::unknown_function, std::move(E2)));
 }
 
 // Profile data is copied from general.proftext
 TEST_F(InstrProfTest, get_profile_summary) {
-  EXPECT_THAT_ERROR(Writer.addRecord({"func1", 0x1234, {97531}}), Succeeded());
-  EXPECT_THAT_ERROR(Writer.addRecord({"func2", 0x1234, {0, 0}}), Succeeded());
-  EXPECT_THAT_ERROR(Writer.addRecord({"func3",
-                                      0x1234,
-                                      {2305843009213693952, 1152921504606846976,
-                                       576460752303423488, 288230376151711744,
-                                       144115188075855872, 72057594037927936}}),
-                    Succeeded());
-  EXPECT_THAT_ERROR(Writer.addRecord({"func4", 0x1234, {0}}), Succeeded());
+  Writer.addRecord(Err, {"func1", 0x1234, {97531}});
+  Writer.addRecord(Err, {"func2", 0x1234, {0, 0}});
+  Writer.addRecord(
+      Err, {"func3",
+            {2305843009213693952, 1152921504606846976, 576460752303423488,
+             288230376151711744, 144115188075855872, 72057594037927936}});
+  Writer.addRecord(Err, {"func4", 0x1234, {0}});
   auto Profile = Writer.writeBuffer();
   readProfile(std::move(Profile));
 
   auto VerifySummary = [](ProfileSummary &IPS) mutable {
     ASSERT_EQ(ProfileSummary::PSK_Instr, IPS.getKind());
     ASSERT_EQ(2305843009213693952U, IPS.getMaxFunctionCount());
     ASSERT_EQ(2305843009213693952U, IPS.getMaxCount());
     ASSERT_EQ(10U, IPS.getNumCounts());
TEST_F(InstrProfTest, get_profile_summary) {
   ASSERT_TRUE(MD);
   PSFromMD = ProfileSummary::getFromMD(MD);
   ASSERT_TRUE(PSFromMD);
   VerifySummary(*PSFromMD);
   delete PSFromMD;
 }
 
 TEST_F(InstrProfTest, test_writer_merge) {
-  EXPECT_THAT_ERROR(Writer.addRecord({"func1", 0x1234, {42}}), Succeeded());
+  Writer.addRecord(Err, {"func1", 0x1234, {42}});
 
   InstrProfWriter Writer2;
-  EXPECT_THAT_ERROR(Writer2.addRecord({"func2", 0x1234, {0, 0}}), Succeeded());
+  Writer2.addRecord(Err, {"func2", 0x1234, {0, 0}});
 
-  EXPECT_THAT_ERROR(Writer.mergeRecordsFromWriter(std::move(Writer2)),
-                    Succeeded());
+  Writer.mergeRecordsFromWriter(Err, std::move(Writer2));
 
   auto Profile = Writer.writeBuffer();
   readProfile(std::move(Profile));
 
   Expected<InstrProfRecord> R = Reader->getInstrProfRecord("func1", 0x1234);
   EXPECT_THAT_ERROR(R.takeError(), Succeeded());
   ASSERT_EQ(1U, R->Counts.size());
   ASSERT_EQ(42U, R->Counts[0]);
TEST_P(MaybeSparseInstrProfTest, get_icall_data_read_write) {
   Record1.addValueData(IPVK_IndirectCallTarget, 0, VD0, 3, nullptr);
   // No value profile data at the second site.
   Record1.addValueData(IPVK_IndirectCallTarget, 1, nullptr, 0, nullptr);
   InstrProfValueData VD2[] = {{(uint64_t)callee1, 1}, {(uint64_t)callee2, 2}};
   Record1.addValueData(IPVK_IndirectCallTarget, 2, VD2, 2, nullptr);
   InstrProfValueData VD3[] = {{(uint64_t)callee1, 1}};
   Record1.addValueData(IPVK_IndirectCallTarget, 3, VD3, 1, nullptr);
 
-  EXPECT_THAT_ERROR(Writer.addRecord(std::move(Record1)), Succeeded());
-  EXPECT_THAT_ERROR(Writer.addRecord({"callee1", 0x1235, {3, 4}}), Succeeded());
-  EXPECT_THAT_ERROR(Writer.addRecord({"callee2", 0x1235, {3, 4}}), Succeeded());
-  EXPECT_THAT_ERROR(Writer.addRecord({"callee3", 0x1235, {3, 4}}), Succeeded());
+  Writer.addRecord(Err, std::move(Record1));
+  Writer.addRecord(Err, {"callee1", 0x1235, {3, 4}});
+  Writer.addRecord(Err, {"callee2", 0x1235, {3, 4}});
+  Writer.addRecord(Err, {"callee3", 0x1235, {3, 4}});
   auto Profile = Writer.writeBuffer();
   readProfile(std::move(Profile));
 
   Expected<InstrProfRecord> R = Reader->getInstrProfRecord("caller", 0x1234);
   EXPECT_THAT_ERROR(R.takeError(), Succeeded());
   ASSERT_EQ(4U, R->getNumValueSites(IPVK_IndirectCallTarget));
   ASSERT_EQ(3U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 0));
   ASSERT_EQ(0U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 1));

 }
 
 TEST_P(MaybeSparseInstrProfTest, annotate_vp_data) {
   NamedInstrProfRecord Record("caller", 0x1234, {1, 2});
   Record.reserveSites(IPVK_IndirectCallTarget, 1);
   InstrProfValueData VD0[] = {{1000, 1}, {2000, 2}, {3000, 3}, {5000, 5},
                               {4000, 4}, {6000, 6}};
   Record.addValueData(IPVK_IndirectCallTarget, 0, VD0, 6, nullptr);
-  EXPECT_THAT_ERROR(Writer.addRecord(std::move(Record)), Succeeded());
+  Writer.addRecord(Err, std::move(Record));
   auto Profile = Writer.writeBuffer();
   readProfile(std::move(Profile));
   Expected<InstrProfRecord> R = Reader->getInstrProfRecord("caller", 0x1234);
   EXPECT_THAT_ERROR(R.takeError(), Succeeded());
 
   LLVMContext Ctx;
   std::unique_ptr<Module> M(new Module("MyModule", Ctx));
   FunctionType *FTy = FunctionType::get(Type::getVoidTy(Ctx),
TEST_P(MaybeSparseInstrProfTest, get_icall_data_read_write_with_weight) {
   Record1.addValueData(IPVK_IndirectCallTarget, 0, VD0, 3, nullptr);
   // No value profile data at the second site.
   Record1.addValueData(IPVK_IndirectCallTarget, 1, nullptr, 0, nullptr);
   InstrProfValueData VD2[] = {{(uint64_t)callee1, 1}, {(uint64_t)callee2, 2}};
   Record1.addValueData(IPVK_IndirectCallTarget, 2, VD2, 2, nullptr);
   InstrProfValueData VD3[] = {{(uint64_t)callee1, 1}};
   Record1.addValueData(IPVK_IndirectCallTarget, 3, VD3, 1, nullptr);
 
-  EXPECT_THAT_ERROR(Writer.addRecord(std::move(Record1), 10), Succeeded());
-  EXPECT_THAT_ERROR(Writer.addRecord({"callee1", 0x1235, {3, 4}}), Succeeded());
-  EXPECT_THAT_ERROR(Writer.addRecord({"callee2", 0x1235, {3, 4}}), Succeeded());
-  EXPECT_THAT_ERROR(Writer.addRecord({"callee3", 0x1235, {3, 4}}), Succeeded());
+  Writer.addRecord(Err, std::move(Record1), 10);
+  Writer.addRecord(Err, {"callee1", 0x1235, {3, 4}});
+  Writer.addRecord(Err, {"callee2", 0x1235, {3, 4}});
+  Writer.addRecord(Err, {"callee3", 0x1235, {3, 4}});
   auto Profile = Writer.writeBuffer();
   readProfile(std::move(Profile));
 
   Expected<InstrProfRecord> R = Reader->getInstrProfRecord("caller", 0x1234);
   EXPECT_THAT_ERROR(R.takeError(), Succeeded());
   ASSERT_EQ(4U, R->getNumValueSites(IPVK_IndirectCallTarget));
   ASSERT_EQ(3U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 0));
   ASSERT_EQ(0U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 1));
TEST_P(MaybeSparseInstrProfTest, get_icall_data_read_write_big_endian) {
   Record1.addValueData(IPVK_IndirectCallTarget, 0, VD0, 3, nullptr);
   // No value profile data at the second site.
   Record1.addValueData(IPVK_IndirectCallTarget, 1, nullptr, 0, nullptr);
   InstrProfValueData VD2[] = {{(uint64_t)callee1, 1}, {(uint64_t)callee2, 2}};
   Record1.addValueData(IPVK_IndirectCallTarget, 2, VD2, 2, nullptr);
   InstrProfValueData VD3[] = {{(uint64_t)callee1, 1}};
   Record1.addValueData(IPVK_IndirectCallTarget, 3, VD3, 1, nullptr);
 
-  EXPECT_THAT_ERROR(Writer.addRecord(std::move(Record1)), Succeeded());
-  EXPECT_THAT_ERROR(Writer.addRecord({"callee1", 0x1235, {3, 4}}), Succeeded());
-  EXPECT_THAT_ERROR(Writer.addRecord({"callee2", 0x1235, {3, 4}}), Succeeded());
-  EXPECT_THAT_ERROR(Writer.addRecord({"callee3", 0x1235, {3, 4}}), Succeeded());
+  Writer.addRecord(Err, std::move(Record1));
+  Writer.addRecord(Err, {"callee1", 0x1235, {3, 4}});
+  Writer.addRecord(Err, {"callee2", 0x1235, {3, 4}});
+  Writer.addRecord(Err, {"callee3", 0x1235, {3, 4}});
 
   // Set big endian output.
   Writer.setValueProfDataEndianness(support::big);
 
   auto Profile = Writer.writeBuffer();
   readProfile(std::move(Profile));
 
   // Set big endian input.
TEST_P(MaybeSparseInstrProfTest, get_icall_data_merge1) {
 
   Record12.addValueData(IPVK_IndirectCallTarget, 3, nullptr, 0, nullptr);
 
   InstrProfValueData VD42[] = {{uint64_t(callee1), 1},
                                {uint64_t(callee2), 2},
                                {uint64_t(callee3), 3}};
   Record12.addValueData(IPVK_IndirectCallTarget, 4, VD42, 3, nullptr);
 
-  EXPECT_THAT_ERROR(Writer.addRecord(std::move(Record11)), Succeeded());
+  Writer.addRecord(Err, std::move(Record11));
   // Merge profile data.
-  EXPECT_THAT_ERROR(Writer.addRecord(std::move(Record12)), Succeeded());
+  Writer.addRecord(Err, std::move(Record12));
 
-  EXPECT_THAT_ERROR(Writer.addRecord({callee1, 0x1235, {3, 4}}), Succeeded());
-  EXPECT_THAT_ERROR(Writer.addRecord({callee2, 0x1235, {3, 4}}), Succeeded());
-  EXPECT_THAT_ERROR(Writer.addRecord({callee3, 0x1235, {3, 4}}), Succeeded());
-  EXPECT_THAT_ERROR(Writer.addRecord({callee3, 0x1235, {3, 4}}), Succeeded());
-  EXPECT_THAT_ERROR(Writer.addRecord({callee4, 0x1235, {3, 5}}), Succeeded());
+  Writer.addRecord(Err, {callee1, 0x1235, {3, 4}});
+  Writer.addRecord(Err, {callee2, 0x1235, {3, 4}});
+  Writer.addRecord(Err, {callee3, 0x1235, {3, 4}});
+  Writer.addRecord(Err, {callee3, 0x1235, {3, 4}});
+  Writer.addRecord(Err, {callee4, 0x1235, {3, 5}});
   auto Profile = Writer.writeBuffer();
   readProfile(std::move(Profile));
 
   Expected<InstrProfRecord> R = Reader->getInstrProfRecord("caller", 0x1234);
   EXPECT_THAT_ERROR(R.takeError(), Succeeded());
   ASSERT_EQ(5U, R->getNumValueSites(IPVK_IndirectCallTarget));
   ASSERT_EQ(4U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 0));
   ASSERT_EQ(0U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 1));
TEST_P(MaybeSparseInstrProfTest, get_icall_data_merge1) {
   ASSERT_EQ(2U, VD_4[2].Count);
 }
 
 TEST_P(MaybeSparseInstrProfTest, get_icall_data_merge1_saturation) {
   static const char bar[] = "bar";
 
   const uint64_t Max = std::numeric_limits<uint64_t>::max();
 
-  auto Result1 = Writer.addRecord({"foo", 0x1234, {1}});
-  ASSERT_EQ(InstrProfError::take(std::move(Result1)),
-            instrprof_error::success);
+  instrprof_error Result;
+  auto Err = [&](Error E) { Result = InstrProfError::take(std::move(E)); };
+  Result = instrprof_error::success;
+  Writer.addRecord(Err, {"foo", 0x1234, {1}});
+  ASSERT_EQ(Result, instrprof_error::success);
 
   // Verify counter overflow.
-  auto Result2 = Writer.addRecord({"foo", 0x1234, {Max}});
-  ASSERT_EQ(InstrProfError::take(std::move(Result2)),
-            instrprof_error::counter_overflow);
-
-  auto Result3 = Writer.addRecord({bar, 0x9012, {8}});
-  ASSERT_EQ(InstrProfError::take(std::move(Result3)),
-            instrprof_error::success);
+  Result = instrprof_error::success;
+  Writer.addRecord(Err, {"foo", 0x1234, {Max}});
+  ASSERT_EQ(Result, instrprof_error::counter_overflow);
+
+  Result = instrprof_error::success;
+  Writer.addRecord(Err, {bar, 0x9012, {8}});
+  ASSERT_EQ(Result, instrprof_error::success);
 
   NamedInstrProfRecord Record4("baz", 0x5678, {3, 4});
   Record4.reserveSites(IPVK_IndirectCallTarget, 1);
   InstrProfValueData VD4[] = {{uint64_t(bar), 1}};
   Record4.addValueData(IPVK_IndirectCallTarget, 0, VD4, 1, nullptr);
-  auto Result4 = Writer.addRecord(std::move(Record4));
-  ASSERT_EQ(InstrProfError::take(std::move(Result4)),
-            instrprof_error::success);
+  Result = instrprof_error::success;
+  Writer.addRecord(Err, std::move(Record4));
+  ASSERT_EQ(Result, instrprof_error::success);
 
   // Verify value data counter overflow.
   NamedInstrProfRecord Record5("baz", 0x5678, {5, 6});
   Record5.reserveSites(IPVK_IndirectCallTarget, 1);
   InstrProfValueData VD5[] = {{uint64_t(bar), Max}};
   Record5.addValueData(IPVK_IndirectCallTarget, 0, VD5, 1, nullptr);
-  auto Result5 = Writer.addRecord(std::move(Record5));
-  ASSERT_EQ(InstrProfError::take(std::move(Result5)),
-            instrprof_error::counter_overflow);
+  Result = instrprof_error::success;
+  Writer.addRecord(Err, std::move(Record5));
+  ASSERT_EQ(Result, instrprof_error::counter_overflow);
 
   auto Profile = Writer.writeBuffer();
   readProfile(std::move(Profile));
 
   // Verify saturation of counts.
   Expected<InstrProfRecord> ReadRecord1 =
       Reader->getInstrProfRecord("foo", 0x1234);
   EXPECT_THAT_ERROR(ReadRecord1.takeError(), Succeeded());
TEST_P(MaybeSparseInstrProfTest, get_icall_data_merge_site_trunc) {
   for (int I = 0; I < 255; I++) {
     VD1[I].Value = 2 * I + 1;
     VD1[I].Count = 2 * I + 1001;
   }
 
   Record12.addValueData(IPVK_IndirectCallTarget, 0, VD1, 255, nullptr);
   Record12.addValueData(IPVK_IndirectCallTarget, 1, nullptr, 0, nullptr);
 
-  EXPECT_THAT_ERROR(Writer.addRecord(std::move(Record11)), Succeeded());
+  Writer.addRecord(Err, std::move(Record11));
   // Merge profile data.
-  EXPECT_THAT_ERROR(Writer.addRecord(std::move(Record12)), Succeeded());
+  Writer.addRecord(Err, std::move(Record12));
 
   auto Profile = Writer.writeBuffer();
   readProfile(std::move(Profile));
 
   Expected<InstrProfRecord> R = Reader->getInstrProfRecord("caller", 0x1234);
   EXPECT_THAT_ERROR(R.takeError(), Succeeded());
   std::unique_ptr<InstrProfValueData[]> VD(
       R->getValueForSite(IPVK_IndirectCallTarget, 0));
TEST_P(MaybeSparseInstrProfTest, value_prof_data_read_write_mapping) {
   ASSERT_EQ(VD_0[2].Value, 0x1000ULL);
   ASSERT_EQ(400U, VD_0[2].Count);
 
   // callee5 does not have a mapped value -- default to 0.
   ASSERT_EQ(VD_0[4].Value, 0ULL);
 }
 
 TEST_P(MaybeSparseInstrProfTest, get_max_function_count) {
-  EXPECT_THAT_ERROR(Writer.addRecord({"foo", 0x1234, {1ULL << 31, 2}}),
-                    Succeeded());
-  EXPECT_THAT_ERROR(Writer.addRecord({"bar", 0, {1ULL << 63}}), Succeeded());
-  EXPECT_THAT_ERROR(Writer.addRecord({"baz", 0x5678, {0, 0, 0, 0}}),
-                    Succeeded());
+  Writer.addRecord(Err, {"foo", 0x1234, {1ULL << 31, 2}});
+  Writer.addRecord(Err, {"bar", 0, {1ULL << 63}});
+  Writer.addRecord(Err, {"baz", 0x5678, {0, 0, 0, 0}});
   auto Profile = Writer.writeBuffer();
   readProfile(std::move(Profile));
 
   ASSERT_EQ(1ULL << 63, Reader->getMaximumFunctionCount());
 }
 
 TEST_P(MaybeSparseInstrProfTest, get_weighted_function_counts) {
-  EXPECT_THAT_ERROR(Writer.addRecord({"foo", 0x1234, {1, 2}}, 3), Succeeded());
-  EXPECT_THAT_ERROR(Writer.addRecord({"foo", 0x1235, {3, 4}}, 5), Succeeded());
+  Writer.addRecord(Err, {"foo", 0x1234, {1, 2}}, 3);
+  Writer.addRecord(Err, {"foo", 0x1235, {3, 4}}, 5);
   auto Profile = Writer.writeBuffer();
   readProfile(std::move(Profile));
 
   std::vector<uint64_t> Counts;
   EXPECT_THAT_ERROR(Reader->getFunctionCounts("foo", 0x1234, Counts),
                     Succeeded());
   ASSERT_EQ(2U, Counts.size());
   ASSERT_EQ(3U, Counts[0]);
for (int Padding = 0; Padding < 2; Padding++) {
           ASSERT_EQ(StringRef(N[J]), R);
         }
       }
     }
   }
 }
 
 TEST_F(SparseInstrProfTest, preserve_no_records) {
-  EXPECT_THAT_ERROR(Writer.addRecord({"foo", 0x1234, {0}}), Succeeded());
-  EXPECT_THAT_ERROR(Writer.addRecord({"bar", 0x4321, {0, 0}}), Succeeded());
+  Writer.addRecord(Err, {"foo", 0x1234, {0}});
+  Writer.addRecord(Err, {"bar", 0x4321, {0, 0}});
   // FIXME: I'm guessing this data should be different, but the original author
   // should check/update this test so it doesn't produce errors.
-  consumeError(Writer.addRecord({"bar", 0x4321, {0, 0, 0}}));
+  Writer.addRecord([](Error E) { consumeError(std::move(E)); },
+                   {"bar", 0x4321, {0, 0, 0}});
 
   auto Profile = Writer.writeBuffer();
   readProfile(std::move(Profile));
 
   auto I = Reader->begin(), E = Reader->end();
   ASSERT_TRUE(I == E);
 }
 
 INSTANTIATE_TEST_CASE_P(MaybeSparse, MaybeSparseInstrProfTest,
                         ::testing::Bool(),);
 
 } // end anonymous namespace