File Manager

003 File Manager

Current Path: /usr/src/contrib/llvm-project/llvm/tools/llvm-xray

usr / src / contrib / llvm-project / llvm / tools / llvm-xray /

📁 ..
📄 func-id-helper.cpp(2.44 KB)
📄 func-id-helper.h(1.75 KB)
📄 llvm-xray.cpp(1.6 KB)
📄 trie-node.h(3.31 KB)
📄 xray-account.cpp(17.43 KB)
📄 xray-account.h(3.22 KB)
📄 xray-color-helper.cpp(8.5 KB)
📄 xray-color-helper.h(2.99 KB)
📄 xray-converter.cpp(16.12 KB)
📄 xray-converter.h(1.49 KB)
📄 xray-extract.cpp(4.19 KB)
📄 xray-fdr-dump.cpp(3.73 KB)
📄 xray-graph-diff.cpp(19.74 KB)
📄 xray-graph-diff.h(2.09 KB)
📄 xray-graph.cpp(20.73 KB)
📄 xray-graph.h(7.38 KB)
📄 xray-registry.cpp(1.28 KB)
📄 xray-registry.h(1.27 KB)
📄 xray-stacks.cpp(31 KB)

Editing: xray-fdr-dump.cpp

//===- xray-fdr-dump.cpp: XRay FDR Trace Dump Tool ------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// Implements the FDR trace dumping tool, using the libraries for handling FDR
// mode traces specifically.
//
//===----------------------------------------------------------------------===//
#include "xray-registry.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/XRay/BlockIndexer.h"
#include "llvm/XRay/BlockPrinter.h"
#include "llvm/XRay/BlockVerifier.h"
#include "llvm/XRay/FDRRecordConsumer.h"
#include "llvm/XRay/FDRRecordProducer.h"
#include "llvm/XRay/FDRRecords.h"
#include "llvm/XRay/FileHeaderReader.h"
#include "llvm/XRay/RecordPrinter.h"

using namespace llvm;
using namespace xray;

static cl::SubCommand Dump("fdr-dump", "FDR Trace Dump");
static cl::opt<std::string> DumpInput(cl::Positional,
                                      cl::desc("<xray fdr mode log>"),
                                      cl::Required, cl::sub(Dump));
static cl::opt<bool> DumpVerify("verify",
                                cl::desc("verify structure of the log"),
                                cl::init(false), cl::sub(Dump));

static CommandRegistration Unused(&Dump, []() -> Error {
  // Open the file provided.
  auto FDOrErr = sys::fs::openNativeFileForRead(DumpInput);
  if (!FDOrErr)
    return FDOrErr.takeError();

uint64_t FileSize;
  if (auto EC = sys::fs::file_size(DumpInput, FileSize))
    return createStringError(EC, "Failed to get file size for '%s'.",
                             DumpInput.c_str());

std::error_code EC;
  sys::fs::mapped_file_region MappedFile(
      *FDOrErr, sys::fs::mapped_file_region::mapmode::readonly, FileSize, 0,
      EC);
  sys::fs::closeFile(*FDOrErr);

DataExtractor DE(StringRef(MappedFile.data(), MappedFile.size()), true, 8);
  uint64_t OffsetPtr = 0;

auto FileHeaderOrError = readBinaryFormatHeader(DE, OffsetPtr);
  if (!FileHeaderOrError)
    return FileHeaderOrError.takeError();
  auto &H = FileHeaderOrError.get();

FileBasedRecordProducer P(H, DE, OffsetPtr);

RecordPrinter RP(outs(), "\n");
  if (!DumpVerify) {
    PipelineConsumer C({&RP});
    while (DE.isValidOffsetForDataOfSize(OffsetPtr, 1)) {
      auto R = P.produce();
      if (!R)
        return R.takeError();
      if (auto E = C.consume(std::move(R.get())))
        return E;
    }
    return Error::success();
  }

BlockPrinter BP(outs(), RP);
  std::vector<std::unique_ptr<Record>> Records;
  LogBuilderConsumer C(Records);
  while (DE.isValidOffsetForDataOfSize(OffsetPtr, 1)) {
    auto R = P.produce();
    if (!R) {
      // Print records we've found so far.
      for (auto &Ptr : Records)
        if (auto E = Ptr->apply(RP))
          return joinErrors(std::move(E), R.takeError());
      return R.takeError();
    }
    if (auto E = C.consume(std::move(R.get())))
      return E;
  }

// Once we have a trace, we then index the blocks.
  BlockIndexer::Index Index;
  BlockIndexer BI(Index);
  for (auto &Ptr : Records)
    if (auto E = Ptr->apply(BI))
      return E;

if (auto E = BI.flush())
    return E;

// Then we validate while printing each block.
  BlockVerifier BV;
  for (auto ProcessThreadBlocks : Index) {
    auto &Blocks = ProcessThreadBlocks.second;
    for (auto &B : Blocks) {
      for (auto *R : B.Records) {
        if (auto E = R->apply(BV))
          return E;
        if (auto E = R->apply(BP))
          return E;
      }
      BV.reset();
      BP.reset();
    }
  }
  outs().flush();
  return Error::success();
});

003 File Manager

Editing: xray-fdr-dump.cpp

Upload File

Create Folder