CodeBlock.hpp

Go to the documentation of this file.

//===- CodeBlock.hpp ---------------------------------------------*- C++-*-===//
//
//  Copyright (C) 2020 GrammaTech, Inc.
//
//  This code is licensed under the MIT license. See the LICENSE file in the
//  project root for license terms.
//
//  This project is sponsored by the Office of Naval Research, One Liberty
//  Center, 875 N. Randolph Street, Arlington, VA 22203 under contract #
//  N68335-17-C-0700.  The content of the information does not necessarily
//  reflect the position or policy of the Government and no official
//  endorsement should be inferred.
//
//===----------------------------------------------------------------------===//
#ifndef GTIRB_BLOCK_H
#define GTIRB_BLOCK_H
 
#include <gtirb/Addr.hpp>
#include <gtirb/ByteInterval.hpp>
#include <gtirb/CfgNode.hpp>
#include <gtirb/DecodeMode.hpp>
#include <gtirb/Export.hpp>
#include <gtirb/Node.hpp>
#include <gtirb/proto/CodeBlock.pb.h>
#include <boost/range/iterator_range.hpp>
#include <cstdint>
#include <functional>
#include <optional>
#include <vector>
 
 
namespace gtirb {
template <class T> class ErrorOr;
 
namespace proto {
class CodeBlock;
} // namespace proto
 
class GTIRB_EXPORT_API CodeBlock : public CfgNode {
public:
  static CodeBlock* Create(Context& C) { return C.Create<CodeBlock>(C); }
 
  static CodeBlock* Create(Context& C, uint64_t Size,
                           gtirb::DecodeMode DMode = DecodeMode::Default) {
    return C.Create<CodeBlock>(C, Size, DMode);
  }
 
  ByteInterval* getByteInterval() { return Parent; }
  const ByteInterval* getByteInterval() const { return Parent; }
 
  uint64_t getSize() const { return Size; }
 
  gtirb::DecodeMode getDecodeMode() const { return this->DecodeMode; }
 
  uint64_t getOffset() const;
 
  std::optional<Addr> getAddress() const;
 
  void setSize(uint64_t S) {
    if (Observer) {
      std::swap(Size, S);
      [[maybe_unused]] ChangeStatus Status =
          Observer->sizeChange(this, S, Size);
      assert(Status != ChangeStatus::Rejected &&
             "recovering from rejected size change is not implemented yet");
    } else {
      Size = S;
    }
  }
 
  void setDecodeMode(gtirb::DecodeMode DM) {
    if (Observer) {
      std::swap(DecodeMode, DM);
      [[maybe_unused]] ChangeStatus Status =
          Observer->decodeModeChange(this, DM, DecodeMode);
      assert(
          Status != ChangeStatus::Rejected &&
          "recovering from rejected decode mode change is not implemented yet");
    } else {
      DecodeMode = DM;
    }
  }
 
  template <typename T> using bytes_iterator = ByteInterval::bytes_iterator<T>;
  template <typename T> using bytes_range = ByteInterval::bytes_range<T>;
  template <typename T>
  using const_bytes_iterator = ByteInterval::const_bytes_iterator<T>;
  template <typename T>
  using const_bytes_range = ByteInterval::const_bytes_range<T>;
 
  template <typename T> bytes_iterator<T> bytes_begin() {
    assert(Parent && "Block has no byte interval!");
    return bytes_begin<T>(Parent->getBoostEndianOrder());
  }
 
  template <typename T>
  bytes_iterator<T>
  bytes_begin(boost::endian::order InputOrder,
              boost::endian::order OutputOrder = boost::endian::order::native) {
    assert(Parent && "Block has no byte interval!");
    return Parent->bytes_begin<T>(InputOrder, OutputOrder) + getOffset();
  }
 
  template <typename T> bytes_iterator<T> bytes_end() {
    assert(Parent && "Block has no byte interval!");
    return bytes_end<T>(Parent->getBoostEndianOrder());
  }
 
  template <typename T>
  bytes_iterator<T>
  bytes_end(boost::endian::order InputOrder,
            boost::endian::order OutputOrder = boost::endian::order::native) {
    assert(Parent && "Block has no byte interval!");
    return Parent->bytes_begin<T>(InputOrder, OutputOrder) + getOffset() + Size;
  }
 
  template <typename T> bytes_range<T> bytes() {
    assert(Parent && "Block has no byte interval!");
    return bytes<T>(Parent->getBoostEndianOrder());
  }
 
  template <typename T>
  bytes_range<T>
  bytes(boost::endian::order InputOrder,
        boost::endian::order OutputOrder = boost::endian::order::native) {
    assert(Parent && "Block has no byte interval!");
    return bytes_range<T>(bytes_begin<T>(InputOrder, OutputOrder),
                          bytes_end<T>(InputOrder, OutputOrder));
  }
 
  template <typename T> const_bytes_iterator<T> bytes_begin() const {
    assert(Parent && "Block has no byte interval!");
    return bytes_begin<T>(Parent->getBoostEndianOrder());
  }
 
  template <typename T>
  const_bytes_iterator<T> bytes_begin(
      boost::endian::order InputOrder,
      boost::endian::order OutputOrder = boost::endian::order::native) const {
    assert(Parent && "Block has no byte interval!");
    return Parent->bytes_begin<T>(InputOrder, OutputOrder) + getOffset();
  }
 
  template <typename T> const_bytes_iterator<T> bytes_end() const {
    assert(Parent && "Block has no byte interval!");
    return bytes_end<T>(Parent->getBoostEndianOrder());
  }
 
  template <typename T>
  const_bytes_iterator<T> bytes_end(
      boost::endian::order InputOrder,
      boost::endian::order OutputOrder = boost::endian::order::native) const {
    assert(Parent && "Block has no byte interval!");
    return Parent->bytes_begin<T>(InputOrder, OutputOrder) + getOffset() + Size;
  }
 
  template <typename T> const_bytes_range<T> bytes() const {
    assert(Parent && "Block has no byte interval!");
    return bytes<T>(Parent->getBoostEndianOrder());
  }
 
  template <typename T>
  const_bytes_range<T>
  bytes(boost::endian::order InputOrder,
        boost::endian::order OutputOrder = boost::endian::order::native) const {
    assert(Parent && "Block has no byte interval!");
    return const_bytes_range<T>(bytes_begin<T>(InputOrder, OutputOrder),
                                bytes_end<T>(InputOrder, OutputOrder));
  }
 
  template <typename T> T* rawBytes() {
    assert(Parent && "Block has no byte interval!");
    return reinterpret_cast<T*>(Parent->rawBytes<uint8_t>() + getOffset());
  }
 
  template <typename T> const T* rawBytes() const {
    assert(Parent && "Block has no byte interval!");
    return reinterpret_cast<const T*>(Parent->rawBytes<uint8_t>() +
                                      getOffset());
  }
 
  static bool classof(const Node* N) { return N->getKind() == Kind::CodeBlock; }
 
private:
  CodeBlock(Context& C) : CfgNode(C, Kind::CodeBlock) {}
  CodeBlock(Context& C, uint64_t S, gtirb::DecodeMode DMode)
      : CfgNode(C, Kind::CodeBlock), Size(S), DecodeMode(DMode) {}
  CodeBlock(Context& C, uint64_t S, gtirb::DecodeMode DMode, const UUID& U)
      : CfgNode(C, Kind::CodeBlock, U), Size(S), DecodeMode(DMode) {}
 
  void setParent(ByteInterval* BI, CodeBlockObserver* O) {
    Parent = BI;
    Observer = O;
  }
 
  static CodeBlock* Create(Context& C, uint64_t Size, gtirb::DecodeMode DMode,
                           const UUID& U) {
    return C.Create<CodeBlock>(C, Size, DMode, U);
  }
 
  using MessageType = proto::CodeBlock;
 
  void toProtobuf(MessageType* Message) const;
 
  static ErrorOr<CodeBlock*> fromProtobuf(Context& C,
                                          const MessageType& Message);
 
  // Present for testing purposes only.
  void save(std::ostream& Out) const;
 
  // Present for testing purposes only.
  static CodeBlock* load(Context& C, std::istream& In);
 
  ByteInterval* Parent{nullptr};
  CodeBlockObserver* Observer{nullptr};
  uint64_t Size{0};
  gtirb::DecodeMode DecodeMode{DecodeMode::Default};
 
  friend class Context;      // Enables Context::Create
  friend class ByteInterval; // Enables to/fromProtobuf, setByteInterval
  friend class SerializationTestHarness; // Testing support.
};
 
} // namespace gtirb
 
#endif // GTIRB_BLOCK_H