/* Capstone Disassembly Engine, http://www.capstone-engine.org */

/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2022, */

/*    Rot127 <unisono@quyllur.org> 2022-2023 */

/* Automatically translated source file from LLVM. */

/* LLVM-commit: <commit> */

/* LLVM-tag: <tag> */

/* Only small edits allowed. */

/* For multiple similar edits, please create a Patch for the translator. */

/* Capstone's C++ file translator: */

/* https://github.com/capstone-engine/capstone/tree/next/suite/auto-sync */

//===-- RISCVBaseInfo.cpp - Top level definitions for RISC-V MC -----------===//

//

// 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

//

//===----------------------------------------------------------------------===//

//

// This file contains small standalone enum definitions for the RISC-V target

// useful for the compiler back-end and the MC libraries.

//

//===----------------------------------------------------------------------===//

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <capstone/platform.h>

#include "RISCVBaseInfo.h"

#define CONCAT(a, b) CONCAT_(a, b)

#define CONCAT_(a, b) a##_##b

typedef struct {

  unsigned value;

  bool isFractional;

} VLMULDecodeResult;

VLMULDecodeResult decodeVLMUL(RISCVII_VLMUL VLMUL)

{

  switch (VLMUL) {

  default:

    CS_ASSERT(0 && "Unexpected LMUL value!");

    break;

  case RISCVII_LMUL_1:

  case RISCVII_LMUL_2:

  case RISCVII_LMUL_4:

  case RISCVII_LMUL_8: {

    VLMULDecodeResult result = { .value = 1 << (unsigned)(VLMUL),

               .isFractional = false };

    return result;

  }

  case RISCVII_LMUL_F2:

  case RISCVII_LMUL_F4:

  case RISCVII_LMUL_F8: {

    VLMULDecodeResult result = { .value = 1 << (8 -

                  (unsigned)(VLMUL)),

               .isFractional = true };

    return result;

  }

  }

  VLMULDecodeResult result = { .value = 0, .isFractional = false };

  return result;

}

void printVType(unsigned VType, SStream *OS)

{

  unsigned Sew = RISCVVType_getSEW(VType);

  SStream_concat(OS, "%s", "e");

  printUInt64(OS, Sew);

  unsigned LMul;

  bool Fractional;

  VLMULDecodeResult result = decodeVLMUL(RISCVVType_getVLMUL(VType));

  LMul = result.value;

  Fractional = result.isFractional;

  if (Fractional)

    SStream_concat0(OS, ", mf");

  else

    SStream_concat0(OS, ", m");

  printUInt64(OS, LMul);

  if (RISCVVType_isTailAgnostic(VType))

    SStream_concat0(OS, ", ta");

  else

    SStream_concat0(OS, ", tu");

  if (RISCVVType_isMaskAgnostic(VType))

    SStream_concat0(OS, ", ma");

  else

    SStream_concat0(OS, ", mu");

}

typedef struct {

  uint8_t first;

  uint8_t second;

} LoadFP32ImmArrElement;

// Lookup table for fli.s for entries 2-31.

static const LoadFP32ImmArrElement LoadFP32ImmArr[] = {

  { 0x6f, 0x00 }, { 0x70, 0x00 }, { 0x77, 0x00 }, { 0x78, 0x00 },

  { 0x7b, 0x00 }, { 0x7c, 0x00 }, { 0x7d, 0x00 }, { 0x7d, 0x01 },

  { 0x7d, 0x02 }, { 0x7d, 0x03 }, { 0x7e, 0x00 }, { 0x7e, 0x01 },

  { 0x7e, 0x02 }, { 0x7e, 0x03 }, { 0x7f, 0x00 }, { 0x7f, 0x01 },

  { 0x7f, 0x02 }, { 0x7f, 0x03 }, { 0x80, 0x00 }, { 0x80, 0x01 },

  { 0x80, 0x02 }, { 0x81, 0x00 }, { 0x82, 0x00 }, { 0x83, 0x00 },

  { 0x86, 0x00 }, { 0x87, 0x00 }, { 0x8e, 0x00 }, { 0x8f, 0x00 },

  { 0xff, 0x00 }, { 0xff, 0x02 },

};

float getFPImm(unsigned Imm)

{

  CS_ASSERT(Imm != 1 && Imm != 30 && Imm != 31 &&

      "Unsupported immediate");

  CS_ASSERT((Imm == 0 || (Imm >= 2 && Imm < 30)) &&

      "Unsupported immediate");

  // Entry 0 is -1.0, the only negative value. Entry 16 is 1.0.

  uint32_t Sign = 0;

  if (Imm == 0) {

    Sign = 0x01;

    Imm = 16;

  }

  uint32_t Exp = LoadFP32ImmArr[Imm - 2].first;

  uint32_t Mantissa = LoadFP32ImmArr[Imm - 2].second;

  uint32_t I = Sign << 31 | Exp << 23 | Mantissa << 21;

  float result;

  memcpy(&result, &I, sizeof(float));

  return result;

}

void RISCVZC_printSpimm(int64_t Spimm, SStream *OS)

{

  printInt32(OS, Spimm);

}

// namespace llvm