LCOV - code coverage report
Current view: top level - lib/Target/AArch64/MCTargetDesc - AArch64MCTargetDesc.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 56 56 100.0 %
Date: 2018-07-13 00:08:38 Functions: 15 16 93.8 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-- AArch64MCTargetDesc.cpp - AArch64 Target Descriptions ---*- C++ -*-===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : //
      10             : // This file provides AArch64 specific target descriptions.
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : 
      14             : #include "AArch64MCTargetDesc.h"
      15             : #include "AArch64ELFStreamer.h"
      16             : #include "AArch64MCAsmInfo.h"
      17             : #include "AArch64WinCOFFStreamer.h"
      18             : #include "InstPrinter/AArch64InstPrinter.h"
      19             : #include "llvm/MC/MCAsmBackend.h"
      20             : #include "llvm/MC/MCCodeEmitter.h"
      21             : #include "llvm/MC/MCInstrAnalysis.h"
      22             : #include "llvm/MC/MCInstrInfo.h"
      23             : #include "llvm/MC/MCObjectWriter.h"
      24             : #include "llvm/MC/MCRegisterInfo.h"
      25             : #include "llvm/MC/MCStreamer.h"
      26             : #include "llvm/MC/MCSubtargetInfo.h"
      27             : #include "llvm/Support/ErrorHandling.h"
      28             : #include "llvm/Support/TargetRegistry.h"
      29             : 
      30             : using namespace llvm;
      31             : 
      32             : #define GET_INSTRINFO_MC_DESC
      33             : #include "AArch64GenInstrInfo.inc"
      34             : 
      35             : #define GET_SUBTARGETINFO_MC_DESC
      36             : #include "AArch64GenSubtargetInfo.inc"
      37             : 
      38             : #define GET_REGINFO_MC_DESC
      39             : #include "AArch64GenRegisterInfo.inc"
      40             : 
      41        3936 : static MCInstrInfo *createAArch64MCInstrInfo() {
      42        3936 :   MCInstrInfo *X = new MCInstrInfo();
      43             :   InitAArch64MCInstrInfo(X);
      44        3936 :   return X;
      45             : }
      46             : 
      47             : static MCSubtargetInfo *
      48        3854 : createAArch64MCSubtargetInfo(const Triple &TT, StringRef CPU, StringRef FS) {
      49        3854 :   if (CPU.empty())
      50        3548 :     CPU = "generic";
      51             : 
      52        3854 :   return createAArch64MCSubtargetInfoImpl(TT, CPU, FS);
      53             : }
      54             : 
      55        5409 : void AArch64_MC::initLLVMToCVRegMapping(MCRegisterInfo *MRI) {
      56     3569940 :   for (unsigned Reg = AArch64::NoRegister + 1;
      57     3575349 :        Reg < AArch64::NUM_TARGET_REGS; ++Reg) {
      58     3569940 :     unsigned CV = MRI->getEncodingValue(Reg);
      59     3569940 :     MRI->mapLLVMRegToCVReg(Reg, CV);
      60             :   }
      61        5409 : }
      62             : 
      63        3968 : static MCRegisterInfo *createAArch64MCRegisterInfo(const Triple &Triple) {
      64        3968 :   MCRegisterInfo *X = new MCRegisterInfo();
      65             :   InitAArch64MCRegisterInfo(X, AArch64::LR);
      66        3968 :   AArch64_MC::initLLVMToCVRegMapping(X);
      67        3968 :   return X;
      68             : }
      69             : 
      70        3951 : static MCAsmInfo *createAArch64MCAsmInfo(const MCRegisterInfo &MRI,
      71             :                                          const Triple &TheTriple) {
      72             :   MCAsmInfo *MAI;
      73        3951 :   if (TheTriple.isOSBinFormatMachO())
      74         524 :     MAI = new AArch64MCAsmInfoDarwin();
      75             :   else if (TheTriple.isWindowsMSVCEnvironment())
      76          33 :     MAI = new AArch64MCAsmInfoMicrosoftCOFF();
      77        3394 :   else if (TheTriple.isOSBinFormatCOFF())
      78           5 :     MAI = new AArch64MCAsmInfoGNUCOFF();
      79             :   else {
      80             :     assert(TheTriple.isOSBinFormatELF() && "Invalid target");
      81        3389 :     MAI = new AArch64MCAsmInfoELF(TheTriple);
      82             :   }
      83             : 
      84             :   // Initial state of the frame pointer is SP.
      85        3951 :   unsigned Reg = MRI.getDwarfRegNum(AArch64::SP, true);
      86             :   MCCFIInstruction Inst = MCCFIInstruction::createDefCfa(nullptr, Reg, 0);
      87             :   MAI->addInitialFrameState(Inst);
      88             : 
      89        3951 :   return MAI;
      90             : }
      91             : 
      92        2589 : static MCInstPrinter *createAArch64MCInstPrinter(const Triple &T,
      93             :                                                  unsigned SyntaxVariant,
      94             :                                                  const MCAsmInfo &MAI,
      95             :                                                  const MCInstrInfo &MII,
      96             :                                                  const MCRegisterInfo &MRI) {
      97        2589 :   if (SyntaxVariant == 0)
      98        2175 :     return new AArch64InstPrinter(MAI, MII, MRI);
      99         414 :   if (SyntaxVariant == 1)
     100         414 :     return new AArch64AppleInstPrinter(MAI, MII, MRI);
     101             : 
     102             :   return nullptr;
     103             : }
     104             : 
     105         625 : static MCStreamer *createELFStreamer(const Triple &T, MCContext &Ctx,
     106             :                                      std::unique_ptr<MCAsmBackend> &&TAB,
     107             :                                      std::unique_ptr<MCObjectWriter> &&OW,
     108             :                                      std::unique_ptr<MCCodeEmitter> &&Emitter,
     109             :                                      bool RelaxAll) {
     110        2500 :   return createAArch64ELFStreamer(Ctx, std::move(TAB), std::move(OW),
     111        1250 :                                   std::move(Emitter), RelaxAll);
     112             : }
     113             : 
     114          34 : static MCStreamer *createMachOStreamer(MCContext &Ctx,
     115             :                                        std::unique_ptr<MCAsmBackend> &&TAB,
     116             :                                        std::unique_ptr<MCObjectWriter> &&OW,
     117             :                                        std::unique_ptr<MCCodeEmitter> &&Emitter,
     118             :                                        bool RelaxAll,
     119             :                                        bool DWARFMustBeAtTheEnd) {
     120          34 :   return createMachOStreamer(Ctx, std::move(TAB), std::move(OW),
     121             :                              std::move(Emitter), RelaxAll, DWARFMustBeAtTheEnd,
     122          34 :                              /*LabelSections*/ true);
     123             : }
     124             : 
     125             : static MCStreamer *
     126          10 : createWinCOFFStreamer(MCContext &Ctx, std::unique_ptr<MCAsmBackend> &&TAB,
     127             :                       std::unique_ptr<MCObjectWriter> &&OW,
     128             :                       std::unique_ptr<MCCodeEmitter> &&Emitter, bool RelaxAll,
     129             :                       bool IncrementalLinkerCompatible) {
     130          40 :   return createAArch64WinCOFFStreamer(Ctx, std::move(TAB), std::move(OW),
     131             :                                       std::move(Emitter), RelaxAll,
     132          20 :                                       IncrementalLinkerCompatible);
     133             : }
     134             : 
     135             : namespace {
     136             : 
     137         521 : class AArch64MCInstrAnalysis : public MCInstrAnalysis {
     138             : public:
     139         522 :   AArch64MCInstrAnalysis(const MCInstrInfo *Info) : MCInstrAnalysis(Info) {}
     140             : 
     141         136 :   bool evaluateBranch(const MCInst &Inst, uint64_t Addr, uint64_t Size,
     142             :                       uint64_t &Target) const override {
     143         272 :     if (Inst.getNumOperands() == 0 ||
     144         272 :         Info->get(Inst.getOpcode()).OpInfo[0].OperandType !=
     145             :             MCOI::OPERAND_PCREL)
     146             :       return false;
     147             : 
     148         106 :     int64_t Imm = Inst.getOperand(0).getImm() * 4;
     149         106 :     Target = Addr + Imm;
     150         106 :     return true;
     151             :   }
     152             : };
     153             : 
     154             : } // end anonymous namespace
     155             : 
     156         522 : static MCInstrAnalysis *createAArch64InstrAnalysis(const MCInstrInfo *Info) {
     157        1044 :   return new AArch64MCInstrAnalysis(Info);
     158             : }
     159             : 
     160             : // Force static initialization.
     161       76105 : extern "C" void LLVMInitializeAArch64TargetMC() {
     162      608840 :   for (Target *T : {&getTheAArch64leTarget(), &getTheAArch64beTarget(),
     163      152210 :                     &getTheARM64Target()}) {
     164             :     // Register the MC asm info.
     165             :     RegisterMCAsmInfoFn X(*T, createAArch64MCAsmInfo);
     166             : 
     167             :     // Register the MC instruction info.
     168             :     TargetRegistry::RegisterMCInstrInfo(*T, createAArch64MCInstrInfo);
     169             : 
     170             :     // Register the MC register info.
     171             :     TargetRegistry::RegisterMCRegInfo(*T, createAArch64MCRegisterInfo);
     172             : 
     173             :     // Register the MC subtarget info.
     174             :     TargetRegistry::RegisterMCSubtargetInfo(*T, createAArch64MCSubtargetInfo);
     175             : 
     176             :     // Register the MC instruction analyzer.
     177             :     TargetRegistry::RegisterMCInstrAnalysis(*T, createAArch64InstrAnalysis);
     178             : 
     179             :     // Register the MC Code Emitter
     180             :     TargetRegistry::RegisterMCCodeEmitter(*T, createAArch64MCCodeEmitter);
     181             : 
     182             :     // Register the obj streamers.
     183             :     TargetRegistry::RegisterELFStreamer(*T, createELFStreamer);
     184             :     TargetRegistry::RegisterMachOStreamer(*T, createMachOStreamer);
     185             :     TargetRegistry::RegisterCOFFStreamer(*T, createWinCOFFStreamer);
     186             : 
     187             :     // Register the obj target streamer.
     188             :     TargetRegistry::RegisterObjectTargetStreamer(
     189             :         *T, createAArch64ObjectTargetStreamer);
     190             : 
     191             :     // Register the asm streamer.
     192             :     TargetRegistry::RegisterAsmTargetStreamer(*T,
     193             :                                               createAArch64AsmTargetStreamer);
     194             :     // Register the MCInstPrinter.
     195             :     TargetRegistry::RegisterMCInstPrinter(*T, createAArch64MCInstPrinter);
     196             :   }
     197             : 
     198             :   // Register the asm backend.
     199      228315 :   for (Target *T : {&getTheAArch64leTarget(), &getTheARM64Target()})
     200             :     TargetRegistry::RegisterMCAsmBackend(*T, createAArch64leAsmBackend);
     201       76105 :   TargetRegistry::RegisterMCAsmBackend(getTheAArch64beTarget(),
     202             :                                        createAArch64beAsmBackend);
     203      375334 : }

Generated by: LCOV version 1.13