LanaiMCTargetDesc.cpp

Go to the documentation of this file.

//===-- LanaiMCTargetDesc.cpp - Lanai Target Descriptions -----------------===//
//
// 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 provides Lanai specific target descriptions.
//
//===----------------------------------------------------------------------===//
 
#include "LanaiMCTargetDesc.h"
#include "LanaiInstPrinter.h"
#include "LanaiMCAsmInfo.h"
#include "TargetInfo/LanaiTargetInfo.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/MC/MCInst.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/MC/TargetRegistry.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/TargetParser/Triple.h"
#include <cstdint>
#include <string>
 
#define GET_INSTRINFO_MC_DESC
#define ENABLE_INSTR_PREDICATE_VERIFIER
#include "LanaiGenInstrInfo.inc"
 
#define GET_SUBTARGETINFO_MC_DESC
#include "LanaiGenSubtargetInfo.inc"
 
#define GET_REGINFO_MC_DESC
#include "LanaiGenRegisterInfo.inc"
 
using namespace llvm;
 
static MCInstrInfo *createLanaiMCInstrInfo() {
  MCInstrInfo *X = new MCInstrInfo();
  InitLanaiMCInstrInfo(X);
  return X;
}
 
static MCRegisterInfo *createLanaiMCRegisterInfo(const Triple & /*TT*/) {
  MCRegisterInfo *X = new MCRegisterInfo();
  InitLanaiMCRegisterInfo(X, Lanai::RCA, 0, 0, Lanai::PC);
  return X;
}
 
static MCSubtargetInfo *
createLanaiMCSubtargetInfo(const Triple &TT, StringRef CPU, StringRef FS) {
  std::string CPUName = std::string(CPU);
  if (CPUName.empty())
    CPUName = "generic";
 
  return createLanaiMCSubtargetInfoImpl(TT, CPUName, /*TuneCPU*/ CPUName, FS);
}
 
static MCStreamer *createMCStreamer(const Triple &T, MCContext &Context,
                                    std::unique_ptr<MCAsmBackend> &&MAB,
                                    std::unique_ptr<MCObjectWriter> &&OW,
                                    std::unique_ptr<MCCodeEmitter> &&Emitter) {
  if (!T.isOSBinFormatELF())
    llvm_unreachable("OS not supported");
 
  return createELFStreamer(Context, std::move(MAB), std::move(OW),
                           std::move(Emitter));
}
 
static MCInstPrinter *createLanaiMCInstPrinter(const Triple & /*T*/,
                                               unsigned SyntaxVariant,
                                               const MCAsmInfo &MAI,
                                               const MCInstrInfo &MII,
                                               const MCRegisterInfo &MRI) {
  if (SyntaxVariant == 0)
    return new LanaiInstPrinter(MAI, MII, MRI);
  return nullptr;
}
 
static MCRelocationInfo *createLanaiElfRelocation(const Triple &TheTriple,
                                                  MCContext &Ctx) {
  return createMCRelocationInfo(TheTriple, Ctx);
}
 
namespace {
 
class LanaiMCInstrAnalysis : public MCInstrAnalysis {
public:
  explicit LanaiMCInstrAnalysis(const MCInstrInfo *Info)
      : MCInstrAnalysis(Info) {}
 
  bool evaluateBranch(const MCInst &Inst, uint64_t Addr, uint64_t Size,
                      uint64_t &Target) const override {
    if (Inst.getNumOperands() == 0)
      return false;
    if (!isConditionalBranch(Inst) && !isUnconditionalBranch(Inst) &&
        !isCall(Inst))
      return false;
 
    if (Info->get(Inst.getOpcode()).operands()[0].OperandType ==
        MCOI::OPERAND_PCREL) {
      int64_t Imm = Inst.getOperand(0).getImm();
      Target = Addr + Size + Imm;
      return true;
    } else {
      int64_t Imm = Inst.getOperand(0).getImm();
 
      // Skip case where immediate is 0 as that occurs in file that isn't linked
      // and the branch target inferred would be wrong.
      if (Imm == 0)
        return false;
 
      Target = Imm;
      return true;
    }
  }
};
 
} // end anonymous namespace
 
static MCTargetStreamer *createNullTargetStreamer(MCStreamer &S) {
  return new MCTargetStreamer(S);
}
 
static MCInstrAnalysis *createLanaiInstrAnalysis(const MCInstrInfo *Info) {
  return new LanaiMCInstrAnalysis(Info);
}
 
extern "C" LLVM_ABI LLVM_EXTERNAL_VISIBILITY void
LLVMInitializeLanaiTargetMC() {
  // Register the MC asm info.
  RegisterMCAsmInfo<LanaiMCAsmInfo> X(getTheLanaiTarget());
 
  // Register the MC instruction info.
  TargetRegistry::RegisterMCInstrInfo(getTheLanaiTarget(),
                                      createLanaiMCInstrInfo);
 
  // Register the MC register info.
  TargetRegistry::RegisterMCRegInfo(getTheLanaiTarget(),
                                    createLanaiMCRegisterInfo);
 
  // Register the MC subtarget info.
  TargetRegistry::RegisterMCSubtargetInfo(getTheLanaiTarget(),
                                          createLanaiMCSubtargetInfo);
 
  // Register the MC code emitter
  TargetRegistry::RegisterMCCodeEmitter(getTheLanaiTarget(),
                                        createLanaiMCCodeEmitter);
 
  // Register the ASM Backend
  TargetRegistry::RegisterMCAsmBackend(getTheLanaiTarget(),
                                       createLanaiAsmBackend);
 
  // Register the MCInstPrinter.
  TargetRegistry::RegisterMCInstPrinter(getTheLanaiTarget(),
                                        createLanaiMCInstPrinter);
 
  // Register the ELF streamer.
  TargetRegistry::RegisterELFStreamer(getTheLanaiTarget(), createMCStreamer);
 
  TargetRegistry::RegisterNullTargetStreamer(getTheLanaiTarget(),
                                             createNullTargetStreamer);
 
  // Register the MC relocation info.
  TargetRegistry::RegisterMCRelocationInfo(getTheLanaiTarget(),
                                           createLanaiElfRelocation);
 
  // Register the MC instruction analyzer.
  TargetRegistry::RegisterMCInstrAnalysis(getTheLanaiTarget(),
                                          createLanaiInstrAnalysis);
}