File Manager

003 File Manager

Current Path: /usr/src/contrib/llvm-project/llvm/lib/Support

usr / src / contrib / llvm-project / llvm / lib / Support /

📁 ..
📄 AArch64TargetParser.cpp(8 KB)
📄 ABIBreak.cpp(811 B)
📄 AMDGPUMetadata.cpp(9.37 KB)
📄 APFloat.cpp(155.26 KB)
📄 APInt.cpp(98.08 KB)
📄 APSInt.cpp(1.44 KB)
📄 ARMAttributeParser.cpp(13.94 KB)
📄 ARMBuildAttrs.cpp(3.45 KB)
📄 ARMTargetParser.cpp(18.09 KB)
📄 ARMWinEH.cpp(1.08 KB)
📄 Allocator.cpp(1.35 KB)
📄 Atomic.cpp(1.6 KB)
📄 BinaryStreamError.cpp(1.76 KB)
📄 BinaryStreamReader.cpp(5.24 KB)
📄 BinaryStreamRef.cpp(4.76 KB)
📄 BinaryStreamWriter.cpp(3.36 KB)
📄 BlockFrequency.cpp(2.12 KB)
📄 BranchProbability.cpp(3.44 KB)
📄 BuryPointer.cpp(1.11 KB)
📄 COM.cpp(737 B)
📄 COPYRIGHT.regex(2.65 KB)
📄 CRC.cpp(5.23 KB)
📄 CachePruning.cpp(10.33 KB)
📄 Chrono.cpp(3.17 KB)
📄 CodeGenCoverage.cpp(3.61 KB)
📄 CommandLine.cpp(89.06 KB)
📄 Compression.cpp(3.84 KB)
📄 ConvertUTF.cpp(27.27 KB)
📄 ConvertUTFWrapper.cpp(8.66 KB)
📄 CrashRecoveryContext.cpp(15.45 KB)
📄 DAGDeltaAlgorithm.cpp(12.47 KB)
📄 DJB.cpp(2.71 KB)
📄 DataExtractor.cpp(7.25 KB)
📄 Debug.cpp(5.64 KB)
📄 DebugCounter.cpp(4.95 KB)
📄 DeltaAlgorithm.cpp(3.41 KB)
📄 DynamicLibrary.cpp(6.25 KB)
📄 ELFAttributeParser.cpp(7.27 KB)
📄 ELFAttributes.cpp(1.27 KB)
📄 Errno.cpp(2.18 KB)
📄 Error.cpp(4.72 KB)
📄 ErrorHandling.cpp(11.08 KB)
📄 ExtensibleRTTI.cpp(446 B)
📄 FileCheck.cpp(95.77 KB)
📄 FileCheckImpl.h(34.14 KB)
📄 FileCollector.cpp(9.01 KB)
📄 FileOutputBuffer.cpp(6.62 KB)
📄 FileUtilities.cpp(10.81 KB)
📄 FoldingSet.cpp(15.89 KB)
📄 FormatVariadic.cpp(5.17 KB)
📄 FormattedStream.cpp(5.29 KB)
📄 GlobPattern.cpp(5 KB)
📄 GraphWriter.cpp(9.21 KB)
📄 Hashing.cpp(1.16 KB)
📄 Host.cpp(51.63 KB)
📄 InitLLVM.cpp(1.92 KB)
📄 IntEqClasses.cpp(2.18 KB)
📄 IntervalMap.cpp(4.4 KB)
📄 ItaniumManglingCanonicalizer.cpp(10.77 KB)
📄 JSON.cpp(19.1 KB)
📄 KnownBits.cpp(3.78 KB)
📄 LEB128.cpp(1.19 KB)
📄 LineIterator.cpp(2.61 KB)
📄 Locale.cpp(377 B)
📄 LockFileManager.cpp(10.64 KB)
📄 LowLevelType.cpp(2.09 KB)
📄 MD5.cpp(8.99 KB)
📄 ManagedStatic.cpp(2.37 KB)
📄 MathExtras.cpp(913 B)
📄 MemAlloc.cpp(1.01 KB)
📄 Memory.cpp(1.57 KB)
📄 MemoryBuffer.cpp(18.99 KB)
📄 NativeFormatting.cpp(7.54 KB)
📄 OptimizedStructLayout.cpp(16.7 KB)
📄 Optional.cpp(530 B)
📄 Parallel.cpp(5.08 KB)
📄 Path.cpp(36.52 KB)
📄 PluginLoader.cpp(1.63 KB)
📄 PrettyStackTrace.cpp(10.33 KB)
📄 Process.cpp(3.27 KB)
📄 Program.cpp(3.54 KB)
📄 RISCVAttributeParser.cpp(2.06 KB)
📄 RISCVAttributes.cpp(970 B)
📄 RWMutex.cpp(3.23 KB)
📄 RandomNumberGenerator.cpp(2.86 KB)
📄 Regex.cpp(6.38 KB)
📄 SHA1.cpp(10.43 KB)
📄 ScaledNumber.cpp(9.09 KB)
📄 ScopedPrinter.cpp(1.19 KB)
📄 Signals.cpp(8.35 KB)
📄 Signposts.cpp(3.24 KB)
📄 SmallPtrSet.cpp(9.21 KB)
📄 SmallVector.cpp(3.99 KB)
📄 SourceMgr.cpp(20.08 KB)
📄 SpecialCaseList.cpp(7.48 KB)
📄 Statistic.cpp(8.85 KB)
📄 StringExtras.cpp(4.34 KB)
📄 StringMap.cpp(9.31 KB)
📄 StringRef.cpp(17.41 KB)
📄 StringSaver.cpp(882 B)
📄 SuffixTree.cpp(7.23 KB)
📄 SymbolRemappingReader.cpp(2.94 KB)
📄 SystemUtils.cpp(1.06 KB)
📄 TarWriter.cpp(7.23 KB)
📄 TargetParser.cpp(9.86 KB)
📄 TargetRegistry.cpp(4.6 KB)
📄 ThreadLocal.cpp(1.68 KB)
📄 ThreadPool.cpp(4.4 KB)
📄 Threading.cpp(4.55 KB)
📄 TimeProfiler.cpp(11.63 KB)
📄 Timer.cpp(14.14 KB)
📄 ToolOutputFile.cpp(1.83 KB)
📄 TrigramIndex.cpp(3.24 KB)
📄 Triple.cpp(53.17 KB)
📄 Twine.cpp(4.6 KB)
📄 Unicode.cpp(20.14 KB)
📄 UnicodeCaseFold.cpp(15.32 KB)
📁 Unix
📄 Valgrind.cpp(1.6 KB)
📄 VersionTuple.cpp(2.74 KB)
📄 VirtualFileSystem.cpp(74.17 KB)
📄 Watchdog.cpp(738 B)
📁 Windows
📄 WithColor.cpp(4.35 KB)
📄 X86TargetParser.cpp(27.21 KB)
📄 YAMLParser.cpp(68.53 KB)
📄 YAMLTraits.cpp(28.37 KB)
📄 Z3Solver.cpp(31.44 KB)
📄 circular_raw_ostream.cpp(1.3 KB)
📄 raw_os_ostream.cpp(995 B)
📄 raw_ostream.cpp(28.97 KB)
📄 regcomp.c(39.42 KB)
📄 regengine.inc(26.49 KB)
📄 regerror.c(4.42 KB)
📄 regex2.h(6.82 KB)
📄 regex_impl.h(3.63 KB)
📄 regexec.c(5.71 KB)
📄 regfree.c(2.49 KB)
📄 regstrlcpy.c(1.56 KB)
📄 regutils.h(2.25 KB)
📄 xxhash.cpp(4.07 KB)

Editing: GraphWriter.cpp

//===- GraphWriter.cpp - Implements GraphWriter support routines ----------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// This file implements misc. GraphWriter support routines.
//
//===----------------------------------------------------------------------===//

#include "llvm/Support/GraphWriter.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Config/config.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/ErrorOr.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/Program.h"
#include "llvm/Support/raw_ostream.h"
#include <cassert>
#include <system_error>
#include <string>
#include <vector>

using namespace llvm;

static cl::opt<bool> ViewBackground("view-background", cl::Hidden,
  cl::desc("Execute graph viewer in the background. Creates tmp file litter."));

std::string llvm::DOT::EscapeString(const std::string &Label) {
  std::string Str(Label);
  for (unsigned i = 0; i != Str.length(); ++i)
  switch (Str[i]) {
    case '\n':
      Str.insert(Str.begin()+i, '\\');  // Escape character...
      ++i;
      Str[i] = 'n';
      break;
    case '\t':
      Str.insert(Str.begin()+i, ' ');  // Convert to two spaces
      ++i;
      Str[i] = ' ';
      break;
    case '\\':
      if (i+1 != Str.length())
        switch (Str[i+1]) {
          case 'l': continue; // don't disturb \l
          case '|': case '{': case '}':
            Str.erase(Str.begin()+i); continue;
          default: break;
        }
        LLVM_FALLTHROUGH;
    case '{': case '}':
    case '<': case '>':
    case '|': case '"':
      Str.insert(Str.begin()+i, '\\');  // Escape character...
      ++i;  // don't infinite loop
      break;
  }
  return Str;
}

/// Get a color string for this node number. Simply round-robin selects
/// from a reasonable number of colors.
StringRef llvm::DOT::getColorString(unsigned ColorNumber) {
  static const int NumColors = 20;
  static const char* Colors[NumColors] = {
    "aaaaaa", "aa0000", "00aa00", "aa5500", "0055ff", "aa00aa", "00aaaa",
    "555555", "ff5555", "55ff55", "ffff55", "5555ff", "ff55ff", "55ffff",
    "ffaaaa", "aaffaa", "ffffaa", "aaaaff", "ffaaff", "aaffff"};
  return Colors[ColorNumber % NumColors];
}

static std::string replaceIllegalFilenameChars(std::string Filename,
                                               const char ReplacementChar) {
#ifdef _WIN32
  std::string IllegalChars = "\\/:?\"<>|";
#else
  std::string IllegalChars = "/";
#endif

for (char IllegalChar : IllegalChars) {
    std::replace(Filename.begin(), Filename.end(), IllegalChar,
                 ReplacementChar);
  }

return Filename;
}

std::string llvm::createGraphFilename(const Twine &Name, int &FD) {
  FD = -1;
  SmallString<128> Filename;

// Windows can't always handle long paths, so limit the length of the name.
  std::string N = Name.str();
  N = N.substr(0, std::min<std::size_t>(N.size(), 140));

// Replace illegal characters in graph Filename with '_' if needed
  std::string CleansedName = replaceIllegalFilenameChars(N, '_');

std::error_code EC =
      sys::fs::createTemporaryFile(CleansedName, "dot", FD, Filename);
  if (EC) {
    errs() << "Error: " << EC.message() << "\n";
    return "";
  }

errs() << "Writing '" << Filename << "'... ";
  return std::string(Filename.str());
}

// Execute the graph viewer. Return true if there were errors.
static bool ExecGraphViewer(StringRef ExecPath, std::vector<StringRef> &args,
                            StringRef Filename, bool wait,
                            std::string &ErrMsg) {
  if (wait) {
    if (sys::ExecuteAndWait(ExecPath, args, None, {}, 0, 0, &ErrMsg)) {
      errs() << "Error: " << ErrMsg << "\n";
      return true;
    }
    sys::fs::remove(Filename);
    errs() << " done. \n";
  } else {
    sys::ExecuteNoWait(ExecPath, args, None, {}, 0, &ErrMsg);
    errs() << "Remember to erase graph file: " << Filename << "\n";
  }
  return false;
}

namespace {

struct GraphSession {
  std::string LogBuffer;

bool TryFindProgram(StringRef Names, std::string &ProgramPath) {
    raw_string_ostream Log(LogBuffer);
    SmallVector<StringRef, 8> parts;
    Names.split(parts, '|');
    for (auto Name : parts) {
      if (ErrorOr<std::string> P = sys::findProgramByName(Name)) {
        ProgramPath = *P;
        return true;
      }
      Log << "  Tried '" << Name << "'\n";
    }
    return false;
  }
};

} // end anonymous namespace

static const char *getProgramName(GraphProgram::Name program) {
  switch (program) {
  case GraphProgram::DOT:
    return "dot";
  case GraphProgram::FDP:
    return "fdp";
  case GraphProgram::NEATO:
    return "neato";
  case GraphProgram::TWOPI:
    return "twopi";
  case GraphProgram::CIRCO:
    return "circo";
  }
  llvm_unreachable("bad kind");
}

bool llvm::DisplayGraph(StringRef FilenameRef, bool wait,
                        GraphProgram::Name program) {
  std::string Filename = std::string(FilenameRef);
  std::string ErrMsg;
  std::string ViewerPath;
  GraphSession S;

#ifdef __APPLE__
  wait &= !ViewBackground;
  if (S.TryFindProgram("open", ViewerPath)) {
    std::vector<StringRef> args;
    args.push_back(ViewerPath);
    if (wait)
      args.push_back("-W");
    args.push_back(Filename);
    errs() << "Trying 'open' program... ";
    if (!ExecGraphViewer(ViewerPath, args, Filename, wait, ErrMsg))
      return false;
  }
#endif
  if (S.TryFindProgram("xdg-open", ViewerPath)) {
    std::vector<StringRef> args;
    args.push_back(ViewerPath);
    args.push_back(Filename);
    errs() << "Trying 'xdg-open' program... ";
    if (!ExecGraphViewer(ViewerPath, args, Filename, wait, ErrMsg))
      return false;
  }

// Graphviz
  if (S.TryFindProgram("Graphviz", ViewerPath)) {
    std::vector<StringRef> args;
    args.push_back(ViewerPath);
    args.push_back(Filename);

errs() << "Running 'Graphviz' program... ";
    return ExecGraphViewer(ViewerPath, args, Filename, wait, ErrMsg);
  }

// xdot
  if (S.TryFindProgram("xdot|xdot.py", ViewerPath)) {
    std::vector<StringRef> args;
    args.push_back(ViewerPath);
    args.push_back(Filename);

args.push_back("-f");
    args.push_back(getProgramName(program));

errs() << "Running 'xdot.py' program... ";
    return ExecGraphViewer(ViewerPath, args, Filename, wait, ErrMsg);
  }

enum ViewerKind {
    VK_None,
    VK_OSXOpen,
    VK_XDGOpen,
    VK_Ghostview,
    VK_CmdStart
  };
  ViewerKind Viewer = VK_None;
#ifdef __APPLE__
  if (!Viewer && S.TryFindProgram("open", ViewerPath))
    Viewer = VK_OSXOpen;
#endif
  if (!Viewer && S.TryFindProgram("gv", ViewerPath))
    Viewer = VK_Ghostview;
  if (!Viewer && S.TryFindProgram("xdg-open", ViewerPath))
    Viewer = VK_XDGOpen;
#ifdef _WIN32
  if (!Viewer && S.TryFindProgram("cmd", ViewerPath)) {
    Viewer = VK_CmdStart;
  }
#endif

// PostScript or PDF graph generator + PostScript/PDF viewer
  std::string GeneratorPath;
  if (Viewer &&
      (S.TryFindProgram(getProgramName(program), GeneratorPath) ||
       S.TryFindProgram("dot|fdp|neato|twopi|circo", GeneratorPath))) {
    std::string OutputFilename =
        Filename + (Viewer == VK_CmdStart ? ".pdf" : ".ps");

std::vector<StringRef> args;
    args.push_back(GeneratorPath);
    if (Viewer == VK_CmdStart)
      args.push_back("-Tpdf");
    else
      args.push_back("-Tps");
    args.push_back("-Nfontname=Courier");
    args.push_back("-Gsize=7.5,10");
    args.push_back(Filename);
    args.push_back("-o");
    args.push_back(OutputFilename);

errs() << "Running '" << GeneratorPath << "' program... ";

if (ExecGraphViewer(GeneratorPath, args, Filename, true, ErrMsg))
      return true;

// The lifetime of StartArg must include the call of ExecGraphViewer
    // because the args are passed as vector of char*.
    std::string StartArg;

args.clear();
    args.push_back(ViewerPath);
    switch (Viewer) {
    case VK_OSXOpen:
      args.push_back("-W");
      args.push_back(OutputFilename);
      break;
    case VK_XDGOpen:
      wait = false;
      args.push_back(OutputFilename);
      break;
    case VK_Ghostview:
      args.push_back("--spartan");
      args.push_back(OutputFilename);
      break;
    case VK_CmdStart:
      args.push_back("/S");
      args.push_back("/C");
      StartArg =
          (StringRef("start ") + (wait ? "/WAIT " : "") + OutputFilename).str();
      args.push_back(StartArg);
      break;
    case VK_None:
      llvm_unreachable("Invalid viewer");
    }

ErrMsg.clear();
    return ExecGraphViewer(ViewerPath, args, OutputFilename, wait, ErrMsg);
  }

// dotty
  if (S.TryFindProgram("dotty", ViewerPath)) {
    std::vector<StringRef> args;
    args.push_back(ViewerPath);
    args.push_back(Filename);

// Dotty spawns another app and doesn't wait until it returns
#ifdef _WIN32
    wait = false;
#endif
    errs() << "Running 'dotty' program... ";
    return ExecGraphViewer(ViewerPath, args, Filename, wait, ErrMsg);
  }

errs() << "Error: Couldn't find a usable graph viewer program:\n";
  errs() << S.LogBuffer << "\n";
  return true;
}

003 File Manager

Editing: GraphWriter.cpp

Upload File

Create Folder