//===-- Opcode.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 "lldb/Core/Opcode.h"

#include "lldb/Utility/DataBufferHeap.h"

#include "lldb/Utility/DataExtractor.h"

#include "lldb/Utility/Endian.h"

#include "lldb/Utility/Stream.h"

#include "lldb/lldb-forward.h"

#include <memory>

#include <cinttypes>

using namespace lldb;

using namespace lldb_private;

int Opcode::Dump(Stream *s, uint32_t min_byte_width) {

  const uint32_t previous_bytes = s->GetWrittenBytes();

  switch (m_type) {

  case Opcode::eTypeInvalid:

    s->PutCString("<invalid>");

    break;

  case Opcode::eType8:

    s->Printf("0x%2.2x", m_data.inst8);

    break;

  case Opcode::eType16:

    s->Printf("0x%4.4x", m_data.inst16);

    break;

  case Opcode::eType16_2:

  case Opcode::eType32:

    s->Printf("0x%8.8x", m_data.inst32);

    break;

  case Opcode::eType64:

    s->Printf("0x%16.16" PRIx64, m_data.inst64);

    break;

  case Opcode::eTypeBytes:

    for (uint32_t i = 0; i < m_data.inst.length; 
++i21.8k
) {

      if (i > 0)

        s->PutChar(' ');

      s->Printf("%2.2x", m_data.inst.bytes[i]);

    }

    break;

  }

  uint32_t bytes_written_so_far = s->GetWrittenBytes() - previous_bytes;

  // Add spaces to make sure bytes display comes out even in case opcodes aren't

  // all the same size.

  if (bytes_written_so_far < min_byte_width)

    s->Printf("%*s", min_byte_width - bytes_written_so_far, "");

  return s->GetWrittenBytes() - previous_bytes;

}

lldb::ByteOrder Opcode::GetDataByteOrder() const {

  if (m_byte_order != eByteOrderInvalid) {

    return m_byte_order;

  }

  switch (m_type) {

  case Opcode::eTypeInvalid:

    break;

  case Opcode::eType8:

  case Opcode::eType16:

  case Opcode::eType16_2:

  case Opcode::eType32:

  case Opcode::eType64:

    return endian::InlHostByteOrder();

  case Opcode::eTypeBytes:

    break;

  }

  return eByteOrderInvalid;

}

uint32_t Opcode::GetData(DataExtractor &data) const {

  uint32_t byte_size = GetByteSize();

  uint8_t swap_buf[8];

  const void *buf = nullptr;

  if (byte_size > 0) {

    if (!GetEndianSwap()) {

      if (m_type == Opcode::eType16_2) {

        // 32 bit thumb instruction, we need to sizzle this a bit

        swap_buf[0] = m_data.inst.bytes[2];

        swap_buf[1] = m_data.inst.bytes[3];

        swap_buf[2] = m_data.inst.bytes[0];

        swap_buf[3] = m_data.inst.bytes[1];

        buf = swap_buf;

      } else {

        buf = GetOpcodeDataBytes();

      }

    } else {

      switch (m_type) {

      case Opcode::eTypeInvalid:

        break;

      case Opcode::eType8:

        buf = GetOpcodeDataBytes();

        break;

      case Opcode::eType16:

        *(uint16_t *)swap_buf = llvm::byteswap<uint16_t>(m_data.inst16);

        buf = swap_buf;

        break;

      case Opcode::eType16_2:

        swap_buf[0] = m_data.inst.bytes[1];

        swap_buf[1] = m_data.inst.bytes[0];

        swap_buf[2] = m_data.inst.bytes[3];

        swap_buf[3] = m_data.inst.bytes[2];

        buf = swap_buf;

        break;

      case Opcode::eType32:

        *(uint32_t *)swap_buf = llvm::byteswap<uint32_t>(m_data.inst32);

        buf = swap_buf;

        break;

      case Opcode::eType64:

        *(uint32_t *)swap_buf = llvm::byteswap<uint64_t>(m_data.inst64);

        buf = swap_buf;

        break;

      case Opcode::eTypeBytes:

        buf = GetOpcodeDataBytes();

        break;

      }

    }

  }

  if (buf != nullptr) {

    DataBufferSP buffer_sp;

    buffer_sp = std::make_shared<DataBufferHeap>(buf, byte_size);

    data.SetByteOrder(GetDataByteOrder());

    data.SetData(buffer_sp);

    return byte_size;

  }

  data.Clear();

  return 0;

}