BPFMCTargetDesc.cpp revision 327952 
1//===-- BPFMCTargetDesc.cpp - BPF Target Descriptions ---------------------===//
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 BPF specific target descriptions.
11//
12//===----------------------------------------------------------------------===//
13
14#include "MCTargetDesc/BPFMCTargetDesc.h"
15#include "BPF.h"
16#include "InstPrinter/BPFInstPrinter.h"
17#include "MCTargetDesc/BPFMCAsmInfo.h"
18#include "llvm/MC/MCInstrAnalysis.h"
19#include "llvm/MC/MCInstrInfo.h"
20#include "llvm/MC/MCRegisterInfo.h"
21#include "llvm/MC/MCSubtargetInfo.h"
22#include "llvm/Support/Host.h"
23#include "llvm/Support/TargetRegistry.h"
24
25#define GET_INSTRINFO_MC_DESC
26#include "BPFGenInstrInfo.inc"
27
28#define GET_SUBTARGETINFO_MC_DESC
29#include "BPFGenSubtargetInfo.inc"
30
31#define GET_REGINFO_MC_DESC
32#include "BPFGenRegisterInfo.inc"
33
34using namespace llvm;
35
36static MCInstrInfo *createBPFMCInstrInfo() {
37  MCInstrInfo *X = new MCInstrInfo();
38  InitBPFMCInstrInfo(X);
39  return X;
40}
41
42static MCRegisterInfo *createBPFMCRegisterInfo(const Triple &TT) {
43  MCRegisterInfo *X = new MCRegisterInfo();
44  InitBPFMCRegisterInfo(X, BPF::R11 /* RAReg doesn't exist */);
45  return X;
46}
47
48static MCSubtargetInfo *createBPFMCSubtargetInfo(const Triple &TT,
49                                                 StringRef CPU, StringRef FS) {
50  return createBPFMCSubtargetInfoImpl(TT, CPU, FS);
51}
52
53static MCStreamer *createBPFMCStreamer(const Triple &T, MCContext &Ctx,
54                                       std::unique_ptr<MCAsmBackend> &&MAB,
55                                       raw_pwrite_stream &OS,
56                                       std::unique_ptr<MCCodeEmitter> &&Emitter,
57                                       bool RelaxAll) {
58  return createELFStreamer(Ctx, std::move(MAB), OS, std::move(Emitter),
59                           RelaxAll);
60}
61
62static MCInstPrinter *createBPFMCInstPrinter(const Triple &T,
63                                             unsigned SyntaxVariant,
64                                             const MCAsmInfo &MAI,
65                                             const MCInstrInfo &MII,
66                                             const MCRegisterInfo &MRI) {
67  if (SyntaxVariant == 0)
68    return new BPFInstPrinter(MAI, MII, MRI);
69  return nullptr;
70}
71
72namespace {
73
74class BPFMCInstrAnalysis : public MCInstrAnalysis {
75public:
76  explicit BPFMCInstrAnalysis(const MCInstrInfo *Info)
77      : MCInstrAnalysis(Info) {}
78
79  bool evaluateBranch(const MCInst &Inst, uint64_t Addr, uint64_t Size,
80                      uint64_t &Target) const override {
81    // The target is the 3rd operand of cond inst and the 1st of uncond inst.
82    int16_t Imm;
83    if (isConditionalBranch(Inst)) {
84      Imm = Inst.getOperand(2).getImm();
85    } else if (isUnconditionalBranch(Inst))
86      Imm = Inst.getOperand(0).getImm();
87    else
88      return false;
89
90    Target = Addr + Size + Imm * Size;
91    return true;
92  }
93};
94
95} // end anonymous namespace
96
97static MCInstrAnalysis *createBPFInstrAnalysis(const MCInstrInfo *Info) {
98  return new BPFMCInstrAnalysis(Info);
99}
100
101extern "C" void LLVMInitializeBPFTargetMC() {
102  for (Target *T :
103       {&getTheBPFleTarget(), &getTheBPFbeTarget(), &getTheBPFTarget()}) {
104    // Register the MC asm info.
105    RegisterMCAsmInfo<BPFMCAsmInfo> X(*T);
106
107    // Register the MC instruction info.
108    TargetRegistry::RegisterMCInstrInfo(*T, createBPFMCInstrInfo);
109
110    // Register the MC register info.
111    TargetRegistry::RegisterMCRegInfo(*T, createBPFMCRegisterInfo);
112
113    // Register the MC subtarget info.
114    TargetRegistry::RegisterMCSubtargetInfo(*T,
115                                            createBPFMCSubtargetInfo);
116
117    // Register the object streamer
118    TargetRegistry::RegisterELFStreamer(*T, createBPFMCStreamer);
119
120    // Register the MCInstPrinter.
121    TargetRegistry::RegisterMCInstPrinter(*T, createBPFMCInstPrinter);
122
123    // Register the MC instruction analyzer.
124    TargetRegistry::RegisterMCInstrAnalysis(*T, createBPFInstrAnalysis);
125  }
126
127  // Register the MC code emitter
128  TargetRegistry::RegisterMCCodeEmitter(getTheBPFleTarget(),
129                                        createBPFMCCodeEmitter);
130  TargetRegistry::RegisterMCCodeEmitter(getTheBPFbeTarget(),
131                                        createBPFbeMCCodeEmitter);
132
133  // Register the ASM Backend
134  TargetRegistry::RegisterMCAsmBackend(getTheBPFleTarget(),
135                                       createBPFAsmBackend);
136  TargetRegistry::RegisterMCAsmBackend(getTheBPFbeTarget(),
137                                       createBPFbeAsmBackend);
138
139  if (sys::IsLittleEndianHost) {
140    TargetRegistry::RegisterMCCodeEmitter(getTheBPFTarget(),
141                                          createBPFMCCodeEmitter);
142    TargetRegistry::RegisterMCAsmBackend(getTheBPFTarget(),
143                                         createBPFAsmBackend);
144  } else {
145    TargetRegistry::RegisterMCCodeEmitter(getTheBPFTarget(),
146                                          createBPFbeMCCodeEmitter);
147    TargetRegistry::RegisterMCAsmBackend(getTheBPFTarget(),
148                                         createBPFbeAsmBackend);
149  }
150
151}
152