path: root/lib/Target/AArch64/MCTargetDesc/AArch64MCTargetDesc.cpp

//===-- AArch64MCTargetDesc.cpp - AArch64 Target Descriptions -------------===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file provides AArch64 specific target descriptions.
//
//===----------------------------------------------------------------------===//

#include "AArch64MCTargetDesc.h"
#include "AArch64BaseInfo.h"
#include "AArch64ELFStreamer.h"
#include "AArch64MCAsmInfo.h"
#include "InstPrinter/AArch64InstPrinter.h"
#include "llvm/ADT/APFloat.h"
#include "llvm/ADT/APInt.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/MC/MCCodeGenInfo.h"
#include "llvm/MC/MCInstrAnalysis.h"
#include "llvm/MC/MCInstrInfo.h"
#include "llvm/MC/MCRegisterInfo.h"
#include "llvm/MC/MCStreamer.h"
#include "llvm/MC/MCSubtargetInfo.h"
#include "llvm/Support/Regex.h"
#include "llvm/Support/TargetRegistry.h"
#include "llvm/Support/ErrorHandling.h"

#define GET_REGINFO_MC_DESC
#include "AArch64GenRegisterInfo.inc"

#define GET_INSTRINFO_MC_DESC
#include "AArch64GenInstrInfo.inc"

#define GET_SUBTARGETINFO_MC_DESC
#include "AArch64GenSubtargetInfo.inc"

using namespace llvm;

StringRef NamedImmMapper::toString(uint32_t Value, bool &Valid) const {
  for (unsigned i = 0; i < NumPairs; ++i) {
    if (Pairs[i].Value == Value) {
      Valid = true;
      return Pairs[i].Name;
    }
  }

  Valid = false;
  return StringRef();
}

uint32_t NamedImmMapper::fromString(StringRef Name, bool &Valid) const {
  std::string LowerCaseName = Name.lower();
  for (unsigned i = 0; i < NumPairs; ++i) {
    if (Pairs[i].Name == LowerCaseName) {
      Valid = true;
      return Pairs[i].Value;
    }
  }

  Valid = false;
  return -1;
}

bool NamedImmMapper::validImm(uint32_t Value) const {
  return Value < TooBigImm;
}

const NamedImmMapper::Mapping A64AT::ATMapper::ATPairs[] = {
  {"s1e1r", S1E1R},
  {"s1e2r", S1E2R},
  {"s1e3r", S1E3R},
  {"s1e1w", S1E1W},
  {"s1e2w", S1E2W},
  {"s1e3w", S1E3W},
  {"s1e0r", S1E0R},
  {"s1e0w", S1E0W},
  {"s12e1r", S12E1R},
  {"s12e1w", S12E1W},
  {"s12e0r", S12E0R},
  {"s12e0w", S12E0W},
};

A64AT::ATMapper::ATMapper()
  : NamedImmMapper(ATPairs, 0) {}

const NamedImmMapper::Mapping A64DB::DBarrierMapper::DBarrierPairs[] = {
  {"oshld", OSHLD},
  {"oshst", OSHST},
  {"osh", OSH},
  {"nshld", NSHLD},
  {"nshst", NSHST},
  {"nsh", NSH},
  {"ishld", ISHLD},
  {"ishst", ISHST},
  {"ish", ISH},
  {"ld", LD},
  {"st", ST},
  {"sy", SY}
};

A64DB::DBarrierMapper::DBarrierMapper()
  : NamedImmMapper(DBarrierPairs, 16u) {}

const NamedImmMapper::Mapping A64DC::DCMapper::DCPairs[] = {
  {"zva", ZVA},
  {"ivac", IVAC},
  {"isw", ISW},
  {"cvac", CVAC},
  {"csw", CSW},
  {"cvau", CVAU},
  {"civac", CIVAC},
  {"cisw", CISW}
};

A64DC::DCMapper::DCMapper()
  : NamedImmMapper(DCPairs, 0) {}

const NamedImmMapper::Mapping A64IC::ICMapper::ICPairs[] = {
  {"ialluis",  IALLUIS},
  {"iallu", IALLU},
  {"ivau", IVAU}
};

A64IC::ICMapper::ICMapper()
  : NamedImmMapper(ICPairs, 0) {}

const NamedImmMapper::Mapping A64ISB::ISBMapper::ISBPairs[] = {
  {"sy",  SY},
};

A64ISB::ISBMapper::ISBMapper()
  : NamedImmMapper(ISBPairs, 16) {}

const NamedImmMapper::Mapping A64PRFM::PRFMMapper::PRFMPairs[] = {
  {"pldl1keep", PLDL1KEEP},
  {"pldl1strm", PLDL1STRM},
  {"pldl2keep", PLDL2KEEP},
  {"pldl2strm", PLDL2STRM},
  {"pldl3keep", PLDL3KEEP},
  {"pldl3strm", PLDL3STRM},
  {"pstl1keep", PSTL1KEEP},
  {"pstl1strm", PSTL1STRM},
  {"pstl2keep", PSTL2KEEP},
  {&