lib/DebugInfo/GSYM/Header.cpp

   1 //===- Header.cpp -----------------------------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "llvm/DebugInfo/GSYM/Header.h"
  10 #include "llvm/DebugInfo/GSYM/FileWriter.h"
  11 #include "llvm/Support/DataExtractor.h"
  12 #include "llvm/Support/Format.h"
  13 #include "llvm/Support/raw_ostream.h"
  14
  15 #define HEX8(v) llvm::format_hex(v, 4)
  16 #define HEX16(v) llvm::format_hex(v, 6)
  17 #define HEX32(v) llvm::format_hex(v, 10)
  18 #define HEX64(v) llvm::format_hex(v, 18)
  19
  20 using namespace llvm;
  21 using namespace gsym;
  22
  23 raw_ostream &llvm::gsym::operator<<(raw_ostream &OS, const Header &H) {
  24   OS << "Header:\n";
  25   OS << "  Magic        = " << HEX32(H.Magic) << "\n";
  26   OS << "  Version      = " << HEX16(H.Version) << '\n';
  27   OS << "  AddrOffSize  = " << HEX8(H.AddrOffSize) << '\n';
  28   OS << "  UUIDSize     = " << HEX8(H.UUIDSize) << '\n';
  29   OS << "  BaseAddress  = " << HEX64(H.BaseAddress) << '\n';
  30   OS << "  NumAddresses = " << HEX32(H.NumAddresses) << '\n';
  31   OS << "  StrtabOffset = " << HEX32(H.StrtabOffset) << '\n';
  32   OS << "  StrtabSize   = " << HEX32(H.StrtabSize) << '\n';
  33   OS << "  UUID         = ";
  34   for (uint8_t I = 0; I < H.UUIDSize; ++I)
  35     OS << format_hex_no_prefix(H.UUID[I], 2);
  36   OS << '\n';
  37   return OS;
  38 }
  39
  40 /// Check the header and detect any errors.
  41 static llvm::Error getHeaderError(const Header &H) {
  42   if (H.Magic != GSYM_MAGIC)
  43     return createStringError(std::errc::invalid_argument,
  44                              "invalid GSYM magic 0x%8.8x", H.Magic);
  45   if (H.Version != GSYM_VERSION)
  46     return createStringError(std::errc::invalid_argument,
  47                              "unsupported GSYM version %u", H.Version);
  48   switch (H.AddrOffSize) {
  49     case 1: break;
  50     case 2: break;
  51     case 4: break;
  52     case 8: break;
  53     default:
  54         return createStringError(std::errc::invalid_argument,
  55                                  "invalid address offset size %u",
  56                                  H.AddrOffSize);
  57   }
  58   if (H.UUIDSize > GSYM_MAX_UUID_SIZE)
  59     return createStringError(std::errc::invalid_argument,
  60                              "invalid UUID size %u", H.UUIDSize);
  61   return Error::success();
  62 }
  63
  64 llvm::Expected<Header> Header::decode(DataExtractor &Data) {
  65   uint64_t Offset = 0;
  66   // The header is stored as a single blob of data that has a fixed byte size.
  67   if (!Data.isValidOffsetForDataOfSize(Offset, sizeof(Header)))
  68     return createStringError(std::errc::invalid_argument,
  69                              "not enough data for a gsym::Header");
  70   Header H;
  71   H.Magic = Data.getU32(&Offset);
  72   H.Version = Data.getU16(&Offset);
  73   H.AddrOffSize = Data.getU8(&Offset);
  74   H.UUIDSize = Data.getU8(&Offset);
  75   H.BaseAddress = Data.getU64(&Offset);
  76   H.NumAddresses = Data.getU32(&Offset);
  77   H.StrtabOffset = Data.getU32(&Offset);
  78   H.StrtabSize = Data.getU32(&Offset);
  79   Data.getU8(&Offset, H.UUID, GSYM_MAX_UUID_SIZE);
  80   llvm::Error Err = getHeaderError(H);
  81   if (Err)
  82     return std::move(Err);
  83   return H;
  84 }
  85
  86 llvm::Error Header::encode(FileWriter &O) const {
  87   // Users must verify the Header is valid prior to calling this funtion.
  88   llvm::Error Err = getHeaderError(*this);
  89   if (Err)
  90     return Err;
  91   O.writeU32(Magic);
  92   O.writeU16(Version);
  93   O.writeU8(AddrOffSize);
  94   O.writeU8(UUIDSize);
  95   O.writeU64(BaseAddress);
  96   O.writeU32(NumAddresses);
  97   O.writeU32(StrtabOffset);
  98   O.writeU32(StrtabSize);
  99   O.writeData(llvm::ArrayRef<uint8_t>(UUID));
 100   return Error::success();
 101 }
 102
 103 bool llvm::gsym::operator==(const Header &LHS, const Header &RHS) {
 104   return LHS.Magic == RHS.Magic && LHS.Version == RHS.Version &&
 105       LHS.AddrOffSize == RHS.AddrOffSize && LHS.UUIDSize == RHS.UUIDSize &&
 106       LHS.BaseAddress == RHS.BaseAddress &&
 107       LHS.NumAddresses == RHS.NumAddresses &&
 108       LHS.StrtabOffset == RHS.StrtabOffset &&
 109       LHS.StrtabSize == RHS.StrtabSize &&
 110       memcmp(LHS.UUID, RHS.UUID, LHS.UUIDSize) == 0;
 111 }