llvm/llvm/lib/Target/SystemZ/MCTargetDesc/SystemZMCTargetDesc.cpp

//===-- SystemZMCTargetDesc.cpp - SystemZ 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
//
//===----------------------------------------------------------------------===//

#include "SystemZMCTargetDesc.h"
#include "SystemZInstPrinter.h"
#include "SystemZMCAsmInfo.h"
#include "SystemZTargetStreamer.h"
#include "TargetInfo/SystemZTargetInfo.h"
#include "llvm/MC/MCContext.h"
#include "llvm/MC/MCDwarf.h"
#include "llvm/MC/MCInst.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"

usingnamespacellvm;

#define GET_INSTRINFO_MC_DESC
#define ENABLE_INSTR_PREDICATE_VERIFIER
#include "SystemZGenInstrInfo.inc"

#define GET_SUBTARGETINFO_MC_DESC
#include "SystemZGenSubtargetInfo.inc"

#define GET_REGINFO_MC_DESC
#include "SystemZGenRegisterInfo.inc"

const unsigned SystemZMC::GR32Regs[16] = …;

const unsigned SystemZMC::GRH32Regs[16] = …;

const unsigned SystemZMC::GR64Regs[16] = …;

const unsigned SystemZMC::GR128Regs[16] = …;

const unsigned SystemZMC::FP32Regs[16] = …;

const unsigned SystemZMC::FP64Regs[16] = …;

const unsigned SystemZMC::FP128Regs[16] = …;

const unsigned SystemZMC::VR32Regs[32] = …;

const unsigned SystemZMC::VR64Regs[32] = …;

const unsigned SystemZMC::VR128Regs[32] = …;

const unsigned SystemZMC::AR32Regs[16] = …;

const unsigned SystemZMC::CR64Regs[16] = …;

unsigned SystemZMC::getFirstReg(unsigned Reg) { … }

static MCAsmInfo *createSystemZMCAsmInfo(const MCRegisterInfo &MRI,
                                         const Triple &TT,
                                         const MCTargetOptions &Options) { … }

static MCInstrInfo *createSystemZMCInstrInfo() { … }

static MCRegisterInfo *createSystemZMCRegisterInfo(const Triple &TT) { … }

static MCSubtargetInfo *
createSystemZMCSubtargetInfo(const Triple &TT, StringRef CPU, StringRef FS) { … }

static MCInstPrinter *createSystemZMCInstPrinter(const Triple &T,
                                                 unsigned SyntaxVariant,
                                                 const MCAsmInfo &MAI,
                                                 const MCInstrInfo &MII,
                                                 const MCRegisterInfo &MRI) { … }

void SystemZTargetStreamer::emitConstantPools() { … }

namespace {
class SystemZTargetAsmStreamer : public SystemZTargetStreamer { … };

class SystemZTargetELFStreamer : public SystemZTargetStreamer { … };
} // end namespace

static MCTargetStreamer *createAsmTargetStreamer(MCStreamer &S,
                                                 formatted_raw_ostream &OS,
                                                 MCInstPrinter *InstPrint) { … }

static MCTargetStreamer *
createObjectTargetStreamer(MCStreamer &S, const MCSubtargetInfo &STI) { … }

static MCTargetStreamer *
createNullTargetStreamer(MCStreamer &S) { … }

extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeSystemZTargetMC() { … }