1 files changed, 25 insertions, 129 deletions

diff --git a/simpleperf/record_file_reader.cpp b/simpleperf/record_file_reader.cpp
index b17086a3..4e246b91 100644
--- a/simpleperf/record_file_reader.cpp
+++ b/simpleperf/record_file_reader.cpp
@@ -49,7 +49,6 @@ static const std::map<int, std::string> feature_name_map = {
     {FEAT_BRANCH_STACK, "branch_stack"},
     {FEAT_PMU_MAPPINGS, "pmu_mappings"},
     {FEAT_GROUP_DESC, "group_desc"},
-    {FEAT_AUXTRACE, "auxtrace"},
     {FEAT_FILE, "file"},
     {FEAT_META_INFO, "meta_info"},
 };
@@ -79,10 +78,9 @@ std::unique_ptr<RecordFileReader> RecordFileReader::CreateInstance(const std::st
   }
   auto reader = std::unique_ptr<RecordFileReader>(new RecordFileReader(filename, fp));
   if (!reader->ReadHeader() || !reader->ReadAttrSection() ||
-      !reader->ReadFeatureSectionDescriptors() || !reader->ReadMetaInfoFeature()) {
+      !reader->ReadFeatureSectionDescriptors()) {
     return nullptr;
   }
-  reader->UseRecordingEnvironment();
   return reader;
 }
 
@@ -207,17 +205,6 @@ bool RecordFileReader::ReadIdsForAttr(const FileAttr& attr, std::vector<uint64_t
   return true;
 }
 
-void RecordFileReader::UseRecordingEnvironment() {
-  std::string arch = ReadFeatureString(FEAT_ARCH);
-  if (!arch.empty()) {
-    scoped_arch_.reset(new ScopedCurrentArch(GetArchType(arch)));
-  }
-  auto& meta_info = GetMetaInfoFeature();
-  if (auto it = meta_info.find("event_type_info"); it != meta_info.end()) {
-    scoped_event_types_.reset(new ScopedEventTypes(it->second));
-  }
-}
-
 bool RecordFileReader::ReadDataSection(
     const std::function<bool(std::unique_ptr<Record>)>& callback) {
   std::unique_ptr<Record> record;
@@ -241,7 +228,7 @@ bool RecordFileReader::ReadRecord(std::unique_ptr<Record>& record) {
   }
   record = nullptr;
   if (read_record_size_ < header_.data.size) {
-    record = ReadRecord();
+    record = ReadRecord(&read_record_size_);
     if (record == nullptr) {
       return false;
     }
@@ -252,7 +239,7 @@ bool RecordFileReader::ReadRecord(std::unique_ptr<Record>& record) {
   return true;
 }
 
-std::unique_ptr<Record> RecordFileReader::ReadRecord() {
+std::unique_ptr<Record> RecordFileReader::ReadRecord(uint64_t* nbytes_read) {
   char header_buf[Record::header_size()];
   if (!Read(header_buf, Record::header_size())) {
     return nullptr;
@@ -271,7 +258,7 @@ std::unique_ptr<Record> RecordFileReader::ReadRecord() {
         return nullptr;
       }
       cur_size += bytes_to_read;
-      read_record_size_ += header.size;
+      *nbytes_read += header.size;
       if (!Read(header_buf, Record::header_size())) {
         return nullptr;
       }
@@ -281,7 +268,7 @@ std::unique_ptr<Record> RecordFileReader::ReadRecord() {
       LOG(ERROR) << "SPLIT records are not followed by a SPLIT_END record.";
       return nullptr;
     }
-    read_record_size_ += header.size;
+    *nbytes_read += header.size;
     header = RecordHeader(buf.data());
     p.reset(new char[header.size]);
     memcpy(p.get(), buf.data(), buf.size());
@@ -293,7 +280,7 @@ std::unique_ptr<Record> RecordFileReader::ReadRecord() {
         return nullptr;
       }
     }
-    read_record_size_ += header.size;
+    *nbytes_read += header.size;
   }
 
   const perf_event_attr* attr = &file_attrs_[0].attr;
@@ -318,17 +305,7 @@ std::unique_ptr<Record> RecordFileReader::ReadRecord() {
       }
     }
   }
-  auto r = ReadRecordFromOwnedBuffer(*attr, header.type, p.release());
-  if (r->type() == PERF_RECORD_AUXTRACE) {
-    auto auxtrace = static_cast<AuxTraceRecord*>(r.get());
-    auxtrace->location.file_offset = header_.data.offset + read_record_size_;
-    read_record_size_ += auxtrace->data->aux_size;
-    if (fseek(record_fp_, auxtrace->data->aux_size, SEEK_CUR) != 0) {
-      PLOG(ERROR) << "fseek() failed";
-      return nullptr;
-    }
-  }
-  return r;
+  return ReadRecordFromOwnedBuffer(*attr, header.type, p.release());
 }
 
 bool RecordFileReader::Read(void* buf, size_t len) {
@@ -339,14 +316,6 @@ bool RecordFileReader::Read(void* buf, size_t len) {
   return true;
 }
 
-bool RecordFileReader::ReadAtOffset(uint64_t offset, void* buf, size_t len) {
-  if (fseek(record_fp_, offset, SEEK_SET) != 0) {
-    PLOG(ERROR) << "failed to seek to " << offset;
-    return false;
-  }
-  return Read(buf, len);
-}
-
 void RecordFileReader::ProcessEventIdRecord(const EventIdRecord& r) {
   for (size_t i = 0; i < r.count; ++i) {
     event_ids_for_file_attrs_[r.data[i].attr_id].push_back(r.data[i].event_id);
@@ -373,7 +342,11 @@ bool RecordFileReader::ReadFeatureSection(int feature, std::vector<char>* data)
   if (section.size == 0) {
     return true;
   }
-  if (!ReadAtOffset(section.offset, data->data(), data->size())) {
+  if (fseek(record_fp_, section.offset, SEEK_SET) != 0) {
+    PLOG(ERROR) << "fseek() failed";
+    return false;
+  }
+  if (!Read(data->data(), data->size())) {
     return false;
   }
   return true;
@@ -436,25 +409,6 @@ std::string RecordFileReader::ReadFeatureString(int feature) {
   return p;
 }
 
-std::vector<uint64_t> RecordFileReader::ReadAuxTraceFeature() {
-  std::vector<char> buf;
-  if (!ReadFeatureSection(FEAT_AUXTRACE, &buf)) {
-    return {};
-  }
-  std::vector<uint64_t> auxtrace_offset;
-  const char* p = buf.data();
-  const char* end = buf.data() + buf.size();
-  while (p < end) {
-    uint64_t offset;
-    uint64_t size;
-    MoveFromBinaryFormat(offset, p);
-    auxtrace_offset.push_back(offset);
-    MoveFromBinaryFormat(size, p);
-    CHECK_EQ(size, AuxTraceRecord::Size());
-  }
-  return auxtrace_offset;
-}
-
 bool RecordFileReader::ReadFileFeature(size_t& read_pos,
                                        std::string* file_path,
                                        uint32_t* file_type,
@@ -517,21 +471,19 @@ bool RecordFileReader::ReadFileFeature(size_t& read_pos,
   return true;
 }
 
-bool RecordFileReader::ReadMetaInfoFeature() {
-  if (feature_section_descriptors_.count(FEAT_META_INFO)) {
-    std::vector<char> buf;
-    if (!ReadFeatureSection(FEAT_META_INFO, &buf)) {
-      return false;
-    }
-    const char* p = buf.data();
-    const char* end = buf.data() + buf.size();
-    while (p < end) {
-      const char* key = p;
-      const char* value = key + strlen(key) + 1;
-      CHECK(value < end);
-      meta_info_[p] = value;
-      p = value + strlen(value) + 1;
-    }
+bool RecordFileReader::ReadMetaInfoFeature(std::unordered_map<std::string, std::string>* info_map) {
+  std::vector<char> buf;
+  if (!ReadFeatureSection(FEAT_META_INFO, &buf)) {
+    return false;
+  }
+  const char* p = buf.data();
+  const char* end = buf.data() + buf.size();
+  while (p < end) {
+    const char* key = p;
+    const char* value = key + strlen(key) + 1;
+    CHECK(value < end);
+    (*info_map)[p] = value;
+    p = value + strlen(value) + 1;
   }
   return true;
 }
@@ -560,62 +512,6 @@ void RecordFileReader::LoadBuildIdAndFileFeatures(ThreadTree& thread_tree) {
   }
 }
 
-bool RecordFileReader::ReadAuxData(uint32_t cpu, uint64_t aux_offset, void* buf, size_t size) {
-  long saved_pos = ftell(record_fp_);
-  if (saved_pos == -1) {
-    PLOG(ERROR) << "ftell() failed";
-    return false;
-  }
-  if (aux_data_location_.empty() && !BuildAuxDataLocation()) {
-    return false;
-  }
-  AuxDataLocation* location = nullptr;
-  auto it = aux_data_location_.find(cpu);
-  if (it != aux_data_location_.end()) {
-    auto comp = [](uint64_t aux_offset, const AuxDataLocation& location) {
-      return aux_offset < location.aux_offset;
-    };
-    auto location_it = std::upper_bound(it->second.begin(), it->second.end(), aux_offset, comp);
-    if (location_it != it->second.begin()) {
-      --location_it;
-      if (location_it->aux_offset + location_it->aux_size >= aux_offset + size) {
-        location = &*location_it;
-      }
-    }
-  }
-  if (location == nullptr) {
-    LOG(ERROR) << "failed to find file offset of aux data: cpu " << cpu << ", aux_offset "
-               << aux_offset << ", size " << size;
-    return false;
-  }
-  if (!ReadAtOffset(aux_offset - location->aux_offset + location->file_offset, buf, size)) {
-    return false;
-  }
-  if (fseek(record_fp_, saved_pos, SEEK_SET) != 0) {
-    PLOG(ERROR) << "fseek() failed";
-    return false;
-  }
-  return true;
-}
-
-bool RecordFileReader::BuildAuxDataLocation() {
-  std::vector<uint64_t> auxtrace_offset = ReadAuxTraceFeature();
-  if (auxtrace_offset.empty()) {
-    LOG(ERROR) << "failed to read auxtrace feature section";
-    return false;
-  }
-  std::unique_ptr<char[]> buf(new char[AuxTraceRecord::Size()]);
-  for (auto offset : auxtrace_offset) {
-    if (!ReadAtOffset(offset, buf.get(), AuxTraceRecord::Size())) {
-      return false;
-    }
-    AuxTraceRecord auxtrace(buf.get());
-    aux_data_location_[auxtrace.data->cpu].emplace_back(
-        auxtrace.data->offset, auxtrace.data->aux_size, offset + auxtrace.size());
-  }
-  return true;
-}
-
 std::vector<std::unique_ptr<Record>> RecordFileReader::DataSection() {
   std::vector<std::unique_ptr<Record>> records;
   ReadDataSection([&](std::unique_ptr<Record> record) {