contrib/llvm-project/lldb/source/API/SBFile.cpp

   1 //===-- SBFile.cpp --------------------------------------------------------===//
   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 "lldb/API/SBFile.h"
  10 #include "SBReproducerPrivate.h"
  11 #include "lldb/API/SBError.h"
  12 #include "lldb/Host/File.h"
  13
  14 using namespace lldb;
  15 using namespace lldb_private;
  16
  17 SBFile::~SBFile() = default;
  18
  19 SBFile::SBFile(FileSP file_sp) : m_opaque_sp(file_sp) {
  20   // We have no way to capture the incoming FileSP as the class isn't
  21   // instrumented, so pretend that it's always null.
  22   LLDB_RECORD_CONSTRUCTOR(SBFile, (lldb::FileSP), nullptr);
  23 }
  24
  25 SBFile::SBFile(const SBFile &rhs) : m_opaque_sp(rhs.m_opaque_sp) {
  26   LLDB_RECORD_CONSTRUCTOR(SBFile, (const lldb::SBFile&), rhs);
  27 }
  28
  29 SBFile &SBFile ::operator=(const SBFile &rhs) {
  30   LLDB_RECORD_METHOD(lldb::SBFile &,
  31                      SBFile, operator=,(const lldb::SBFile &), rhs);
  32
  33   if (this != &rhs)
  34     m_opaque_sp = rhs.m_opaque_sp;
  35   return LLDB_RECORD_RESULT(*this);
  36 }
  37
  38 SBFile::SBFile() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFile); }
  39
  40 SBFile::SBFile(FILE *file, bool transfer_ownership) {
  41   LLDB_RECORD_CONSTRUCTOR(SBFile, (FILE *, bool), file, transfer_ownership);
  42
  43   m_opaque_sp = std::make_shared<NativeFile>(file, transfer_ownership);
  44 }
  45
  46 SBFile::SBFile(int fd, const char *mode, bool transfer_owndership) {
  47   LLDB_RECORD_CONSTRUCTOR(SBFile, (int, const char *, bool), fd, mode,
  48                           transfer_owndership);
  49
  50   auto options = File::GetOptionsFromMode(mode);
  51   if (!options) {
  52     llvm::consumeError(options.takeError());
  53     return;
  54   }
  55   m_opaque_sp =
  56       std::make_shared<NativeFile>(fd, options.get(), transfer_owndership);
  57 }
  58
  59 SBError SBFile::Read(uint8_t *buf, size_t num_bytes, size_t *bytes_read) {
  60   LLDB_RECORD_METHOD(lldb::SBError, SBFile, Read, (uint8_t *, size_t, size_t *),
  61                      buf, num_bytes, bytes_read);
  62
  63   SBError error;
  64   if (!m_opaque_sp) {
  65     error.SetErrorString("invalid SBFile");
  66     *bytes_read = 0;
  67   } else {
  68     Status status = m_opaque_sp->Read(buf, num_bytes);
  69     error.SetError(status);
  70     *bytes_read = num_bytes;
  71   }
  72   return LLDB_RECORD_RESULT(error);
  73 }
  74
  75 SBError SBFile::Write(const uint8_t *buf, size_t num_bytes,
  76                       size_t *bytes_written) {
  77   LLDB_RECORD_METHOD(lldb::SBError, SBFile, Write,
  78                      (const uint8_t *, size_t, size_t *), buf, num_bytes,
  79                      bytes_written);
  80
  81   SBError error;
  82   if (!m_opaque_sp) {
  83     error.SetErrorString("invalid SBFile");
  84     *bytes_written = 0;
  85   } else {
  86     Status status = m_opaque_sp->Write(buf, num_bytes);
  87     error.SetError(status);
  88     *bytes_written = num_bytes;
  89   }
  90   return LLDB_RECORD_RESULT(error);
  91 }
  92
  93 SBError SBFile::Flush() {
  94   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBFile, Flush);
  95
  96   SBError error;
  97   if (!m_opaque_sp) {
  98     error.SetErrorString("invalid SBFile");
  99   } else {
 100     Status status = m_opaque_sp->Flush();
 101     error.SetError(status);
 102   }
 103   return LLDB_RECORD_RESULT(error);
 104 }
 105
 106 bool SBFile::IsValid() const {
 107   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFile, IsValid);
 108   return m_opaque_sp && m_opaque_sp->IsValid();
 109 }
 110
 111 SBError SBFile::Close() {
 112   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBFile, Close);
 113   SBError error;
 114   if (m_opaque_sp) {
 115     Status status = m_opaque_sp->Close();
 116     error.SetError(status);
 117   }
 118   return LLDB_RECORD_RESULT(error);
 119 }
 120
 121 SBFile::operator bool() const {
 122   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFile, operator bool);
 123   return IsValid();
 124 }
 125
 126 bool SBFile::operator!() const {
 127   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFile, operator!);
 128   return !IsValid();
 129 }
 130
 131 FileSP SBFile::GetFile() const {
 132   LLDB_RECORD_METHOD_CONST_NO_ARGS(FileSP, SBFile, GetFile);
 133   return LLDB_RECORD_RESULT(m_opaque_sp);
 134 }
 135
 136 namespace lldb_private {
 137 namespace repro {
 138
 139 template <> void RegisterMethods<SBFile>(Registry &R) {
 140   LLDB_REGISTER_CONSTRUCTOR(SBFile, ());
 141   LLDB_REGISTER_CONSTRUCTOR(SBFile, (FileSP));
 142   LLDB_REGISTER_CONSTRUCTOR(SBFile, (const SBFile&));
 143   LLDB_REGISTER_CONSTRUCTOR(SBFile, (FILE *, bool));
 144   LLDB_REGISTER_CONSTRUCTOR(SBFile, (int, const char *, bool));
 145   LLDB_REGISTER_METHOD(SBFile&, SBFile, operator=,(const SBFile&));
 146   LLDB_REGISTER_METHOD(lldb::SBError, SBFile, Flush, ());
 147   LLDB_REGISTER_METHOD(lldb::SBError, SBFile, Read,
 148                        (uint8_t *, size_t, size_t *));
 149   LLDB_REGISTER_METHOD(lldb::SBError, SBFile, Write,
 150                        (const uint8_t *, size_t, size_t *));
 151   LLDB_REGISTER_METHOD_CONST(bool, SBFile, IsValid, ());
 152   LLDB_REGISTER_METHOD_CONST(bool, SBFile, operator bool,());
 153   LLDB_REGISTER_METHOD_CONST(bool, SBFile, operator!,());
 154   LLDB_REGISTER_METHOD_CONST(FileSP, SBFile, GetFile, ());
 155   LLDB_REGISTER_METHOD(lldb::SBError, SBFile, Close, ());
 156 }
 157 } // namespace repro
 158 } // namespace lldb_private