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: DataExtractor.cpp

//===-- DataExtractor.cpp -------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//

#include "llvm/Support/DataExtractor.h"
#include "llvm/Support/Errc.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/Host.h"
#include "llvm/Support/LEB128.h"
#include "llvm/Support/SwapByteOrder.h"

using namespace llvm;

bool DataExtractor::prepareRead(uint64_t Offset, uint64_t Size,
                                Error *E) const {
  if (isValidOffsetForDataOfSize(Offset, Size))
    return true;
  if (E) {
    if (Offset <= Data.size())
      *E = createStringError(
          errc::illegal_byte_sequence,
          "unexpected end of data at offset 0x%zx while reading [0x%" PRIx64
          ", 0x%" PRIx64 ")",
          Data.size(), Offset, Offset + Size);
    else
      *E = createStringError(errc::invalid_argument,
                             "offset 0x%" PRIx64
                             " is beyond the end of data at 0x%zx",
                             Offset, Data.size());
  }
  return false;
}

static bool isError(Error *E) { return E && *E; }

template <typename T>
T DataExtractor::getU(uint64_t *offset_ptr, Error *Err) const {
  ErrorAsOutParameter ErrAsOut(Err);
  T val = 0;
  if (isError(Err))
    return val;

uint64_t offset = *offset_ptr;
  if (!prepareRead(offset, sizeof(T), Err))
    return val;
  std::memcpy(&val, &Data.data()[offset], sizeof(val));
  if (sys::IsLittleEndianHost != IsLittleEndian)
    sys::swapByteOrder(val);

// Advance the offset
  *offset_ptr += sizeof(val);
  return val;
}

template <typename T>
T *DataExtractor::getUs(uint64_t *offset_ptr, T *dst, uint32_t count,
                        Error *Err) const {
  ErrorAsOutParameter ErrAsOut(Err);
  if (isError(Err))
    return nullptr;

uint64_t offset = *offset_ptr;

if (!prepareRead(offset, sizeof(*dst) * count, Err))
    return nullptr;
  for (T *value_ptr = dst, *end = dst + count; value_ptr != end;
       ++value_ptr, offset += sizeof(*dst))
    *value_ptr = getU<T>(offset_ptr, Err);
  // Advance the offset
  *offset_ptr = offset;
  // Return a non-NULL pointer to the converted data as an indicator of
  // success
  return dst;
}

uint8_t DataExtractor::getU8(uint64_t *offset_ptr, llvm::Error *Err) const {
  return getU<uint8_t>(offset_ptr, Err);
}

uint8_t *DataExtractor::getU8(uint64_t *offset_ptr, uint8_t *dst,
                              uint32_t count) const {
  return getUs<uint8_t>(offset_ptr, dst, count, nullptr);
}

uint8_t *DataExtractor::getU8(Cursor &C, uint8_t *Dst, uint32_t Count) const {
  return getUs<uint8_t>(&C.Offset, Dst, Count, &C.Err);
}

uint16_t DataExtractor::getU16(uint64_t *offset_ptr, llvm::Error *Err) const {
  return getU<uint16_t>(offset_ptr, Err);
}

uint16_t *DataExtractor::getU16(uint64_t *offset_ptr, uint16_t *dst,
                                uint32_t count) const {
  return getUs<uint16_t>(offset_ptr, dst, count, nullptr);
}

uint32_t DataExtractor::getU24(uint64_t *OffsetPtr, Error *Err) const {
  uint24_t ExtractedVal = getU<uint24_t>(OffsetPtr, Err);
  // The 3 bytes are in the correct byte order for the host.
  return ExtractedVal.getAsUint32(sys::IsLittleEndianHost);
}

uint32_t DataExtractor::getU32(uint64_t *offset_ptr, llvm::Error *Err) const {
  return getU<uint32_t>(offset_ptr, Err);
}

uint32_t *DataExtractor::getU32(uint64_t *offset_ptr, uint32_t *dst,
                                uint32_t count) const {
  return getUs<uint32_t>(offset_ptr, dst, count, nullptr);
}

uint64_t DataExtractor::getU64(uint64_t *offset_ptr, llvm::Error *Err) const {
  return getU<uint64_t>(offset_ptr, Err);
}

uint64_t *DataExtractor::getU64(uint64_t *offset_ptr, uint64_t *dst,
                                uint32_t count) const {
  return getUs<uint64_t>(offset_ptr, dst, count, nullptr);
}

uint64_t DataExtractor::getUnsigned(uint64_t *offset_ptr, uint32_t byte_size,
                                    llvm::Error *Err) const {
  switch (byte_size) {
  case 1:
    return getU8(offset_ptr, Err);
  case 2:
    return getU16(offset_ptr, Err);
  case 4:
    return getU32(offset_ptr, Err);
  case 8:
    return getU64(offset_ptr, Err);
  }
  llvm_unreachable("getUnsigned unhandled case!");
}

int64_t
DataExtractor::getSigned(uint64_t *offset_ptr, uint32_t byte_size) const {
  switch (byte_size) {
  case 1:
    return (int8_t)getU8(offset_ptr);
  case 2:
    return (int16_t)getU16(offset_ptr);
  case 4:
    return (int32_t)getU32(offset_ptr);
  case 8:
    return (int64_t)getU64(offset_ptr);
  }
  llvm_unreachable("getSigned unhandled case!");
}

StringRef DataExtractor::getCStrRef(uint64_t *OffsetPtr, Error *Err) const {
  ErrorAsOutParameter ErrAsOut(Err);
  if (isError(Err))
    return StringRef();

uint64_t Start = *OffsetPtr;
  StringRef::size_type Pos = Data.find('\0', Start);
  if (Pos != StringRef::npos) {
    *OffsetPtr = Pos + 1;
    return StringRef(Data.data() + Start, Pos - Start);
  }
  if (Err)
    *Err = createStringError(errc::illegal_byte_sequence,
                             "no null terminated string at offset 0x%" PRIx64,
                             Start);
  return StringRef();
}

StringRef DataExtractor::getFixedLengthString(uint64_t *OffsetPtr,
                                              uint64_t Length,
                                              StringRef TrimChars) const {
  StringRef Bytes(getBytes(OffsetPtr, Length));
  return Bytes.trim(TrimChars);
}

StringRef DataExtractor::getBytes(uint64_t *OffsetPtr, uint64_t Length,
                                  Error *Err) const {
  ErrorAsOutParameter ErrAsOut(Err);
  if (isError(Err))
    return StringRef();

if (!prepareRead(*OffsetPtr, Length, Err))
    return StringRef();

StringRef Result = Data.substr(*OffsetPtr, Length);
  *OffsetPtr += Length;
  return Result;
}

template <typename T>
static T getLEB128(StringRef Data, uint64_t *OffsetPtr, Error *Err,
                   T (&Decoder)(const uint8_t *p, unsigned *n,
                                const uint8_t *end, const char **error)) {
  ArrayRef<uint8_t> Bytes = arrayRefFromStringRef(Data);
  assert(*OffsetPtr <= Bytes.size());
  ErrorAsOutParameter ErrAsOut(Err);
  if (isError(Err))
    return T();

const char *error;
  unsigned bytes_read;
  T result =
      Decoder(Bytes.data() + *OffsetPtr, &bytes_read, Bytes.end(), &error);
  if (error) {
    if (Err)
      *Err = createStringError(errc::illegal_byte_sequence,
                               "unable to decode LEB128 at offset 0x%8.8" PRIx64
                               ": %s",
                               *OffsetPtr, error);
    return T();
  }
  *OffsetPtr += bytes_read;
  return result;
}

uint64_t DataExtractor::getULEB128(uint64_t *offset_ptr, Error *Err) const {
  return getLEB128(Data, offset_ptr, Err, decodeULEB128);
}

int64_t DataExtractor::getSLEB128(uint64_t *offset_ptr, Error *Err) const {
  return getLEB128(Data, offset_ptr, Err, decodeSLEB128);
}

void DataExtractor::skip(Cursor &C, uint64_t Length) const {
  ErrorAsOutParameter ErrAsOut(&C.Err);
  if (isError(&C.Err))
    return;

if (prepareRead(C.Offset, Length, &C.Err))
    C.Offset += Length;
}

003 File Manager

Editing: DataExtractor.cpp

Upload File

Create Folder