LLVM 19.0.0git
BPFMCTargetDesc.cpp
Go to the documentation of this file.
1//===-- BPFMCTargetDesc.cpp - BPF Target Descriptions ---------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file provides BPF specific target descriptions.
10//
11//===----------------------------------------------------------------------===//
12
18#include "llvm/MC/MCInstrInfo.h"
23
24#define GET_INSTRINFO_MC_DESC
25#define ENABLE_INSTR_PREDICATE_VERIFIER
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
37 MCInstrInfo *X = new MCInstrInfo();
38 InitBPFMCInstrInfo(X);
39 return X;
40}
41
44 InitBPFMCRegisterInfo(X, BPF::R11 /* RAReg doesn't exist */);
45 return X;
46}
47
49 StringRef CPU, StringRef FS) {
50 return createBPFMCSubtargetInfoImpl(TT, CPU, /*TuneCPU*/ CPU, FS);
51}
52
54 std::unique_ptr<MCAsmBackend> &&MAB,
55 std::unique_ptr<MCObjectWriter> &&OW,
56 std::unique_ptr<MCCodeEmitter> &&Emitter,
57 bool RelaxAll) {
58 return createELFStreamer(Ctx, std::move(MAB), std::move(OW), std::move(Emitter),
59 RelaxAll);
60}
61
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)
78
80 uint64_t &Target) const override {
81 // The target is the 3rd operand of cond inst and the 1st of uncond inst.
82 int32_t Imm;
83 if (isConditionalBranch(Inst)) {
84 if (Inst.getOpcode() == BPF::JCOND)
85 Imm = (short)Inst.getOperand(0).getImm();
86 else
87 Imm = (short)Inst.getOperand(2).getImm();
88 } else if (isUnconditionalBranch(Inst)) {
89 if (Inst.getOpcode() == BPF::JMP)
90 Imm = (short)Inst.getOperand(0).getImm();
91 else
92 Imm = (int)Inst.getOperand(0).getImm();
93 } else
94 return false;
95
96 Target = Addr + Size + Imm * Size;
97 return true;
98 }
99};
100
101} // end anonymous namespace
102
104 return new BPFMCInstrAnalysis(Info);
105}
106
108 for (Target *T :
110 // Register the MC asm info.
112
113 // Register the MC instruction info.
115
116 // Register the MC register info.
118
119 // Register the MC subtarget info.
122
123 // Register the object streamer
125
126 // Register the MCInstPrinter.
128
129 // Register the MC instruction analyzer.
131 }
132
133 // Register the MC code emitter
138
139 // Register the ASM Backend
144
150 } else {
155 }
156
157}
unsigned const MachineRegisterInfo * MRI
static MCStreamer * createBPFMCStreamer(const Triple &T, MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&MAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&Emitter, bool RelaxAll)
static MCSubtargetInfo * createBPFMCSubtargetInfo(const Triple &TT, StringRef CPU, StringRef FS)
LLVM_EXTERNAL_VISIBILITY void LLVMInitializeBPFTargetMC()
static MCInstrAnalysis * createBPFInstrAnalysis(const MCInstrInfo *Info)
static MCInstPrinter * createBPFMCInstPrinter(const Triple &T, unsigned SyntaxVariant, const MCAsmInfo &MAI, const MCInstrInfo &MII, const MCRegisterInfo &MRI)
static MCInstrInfo * createBPFMCInstrInfo()
static MCRegisterInfo * createBPFMCRegisterInfo(const Triple &TT)
Analysis containing CSE Info
Definition: CSEInfo.cpp:27
#define LLVM_EXTERNAL_VISIBILITY
Definition: Compiler.h:135
dxil DXContainer Global Emitter
uint64_t Addr
uint64_t Size
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
This class is intended to be used as a base class for asm properties and features specific to the tar...
Definition: MCAsmInfo.h:56
Context object for machine code objects.
Definition: MCContext.h:76
This is an instance of a target assembly language printer that converts an MCInst to valid target ass...
Definition: MCInstPrinter.h:45
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:184
unsigned getOpcode() const
Definition: MCInst.h:198
const MCOperand & getOperand(unsigned i) const
Definition: MCInst.h:206
virtual bool isUnconditionalBranch(const MCInst &Inst) const
virtual bool evaluateBranch(const MCInst &Inst, uint64_t Addr, uint64_t Size, uint64_t &Target) const
Given a branch instruction try to get the address the branch targets.
virtual bool isConditionalBranch(const MCInst &Inst) const
Interface to description of machine instruction set.
Definition: MCInstrInfo.h:26
int64_t getImm() const
Definition: MCInst.h:80
MCRegisterInfo base class - We assume that the target defines a static array of MCRegisterDesc object...
Streaming machine code generation interface.
Definition: MCStreamer.h:212
Generic base class for all target subtargets.
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Target - Wrapper for Target specific information.
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
static const bool IsLittleEndianHost
Definition: SwapByteOrder.h:29
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
Target & getTheBPFleTarget()
MCAsmBackend * createBPFAsmBackend(const Target &T, const MCSubtargetInfo &STI, const MCRegisterInfo &MRI, const MCTargetOptions &Options)
Target & getTheBPFbeTarget()
MCAsmBackend * createBPFbeAsmBackend(const Target &T, const MCSubtargetInfo &STI, const MCRegisterInfo &MRI, const MCTargetOptions &Options)
Target & getTheBPFTarget()
MCCodeEmitter * createBPFbeMCCodeEmitter(const MCInstrInfo &MCII, MCContext &Ctx)
MCStreamer * createELFStreamer(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&CE, bool RelaxAll)
MCCodeEmitter * createBPFMCCodeEmitter(const MCInstrInfo &MCII, MCContext &Ctx)
RegisterMCAsmInfo - Helper template for registering a target assembly info implementation.
static void RegisterMCRegInfo(Target &T, Target::MCRegInfoCtorFnTy Fn)
RegisterMCRegInfo - Register a MCRegisterInfo implementation for the given target.
static void RegisterMCAsmBackend(Target &T, Target::MCAsmBackendCtorTy Fn)
RegisterMCAsmBackend - Register a MCAsmBackend implementation for the given target.
static void RegisterMCCodeEmitter(Target &T, Target::MCCodeEmitterCtorTy Fn)
RegisterMCCodeEmitter - Register a MCCodeEmitter implementation for the given target.
static void RegisterMCSubtargetInfo(Target &T, Target::MCSubtargetInfoCtorFnTy Fn)
RegisterMCSubtargetInfo - Register a MCSubtargetInfo implementation for the given target.
static void RegisterMCInstrAnalysis(Target &T, Target::MCInstrAnalysisCtorFnTy Fn)
RegisterMCInstrAnalysis - Register a MCInstrAnalysis implementation for the given target.
static void RegisterELFStreamer(Target &T, Target::ELFStreamerCtorTy Fn)
static void RegisterMCInstPrinter(Target &T, Target::MCInstPrinterCtorTy Fn)
RegisterMCInstPrinter - Register a MCInstPrinter implementation for the given target.
static void RegisterMCInstrInfo(Target &T, Target::MCInstrInfoCtorFnTy Fn)
RegisterMCInstrInfo - Register a MCInstrInfo implementation for the given target.