lib/Target/BPF/BPFTargetMachine.cpp

   1 //===-- BPFTargetMachine.cpp - Define TargetMachine for BPF ---------------===//
   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 // Implements the info about BPF target spec.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "BPFTargetMachine.h"
  14 #include "BPF.h"
  15 #include "MCTargetDesc/BPFMCAsmInfo.h"
  16 #include "TargetInfo/BPFTargetInfo.h"
  17 #include "llvm/CodeGen/Passes.h"
  18 #include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
  19 #include "llvm/CodeGen/TargetPassConfig.h"
  20 #include "llvm/IR/LegacyPassManager.h"
  21 #include "llvm/Support/FormattedStream.h"
  22 #include "llvm/Support/TargetRegistry.h"
  23 #include "llvm/Target/TargetOptions.h"
  24 using namespace llvm;
  25
  26 static cl::
  27 opt<bool> DisableMIPeephole("disable-bpf-peephole", cl::Hidden,
  28                             cl::desc("Disable machine peepholes for BPF"));
  29
  30 extern "C" void LLVMInitializeBPFTarget() {
  31   // Register the target.
  32   RegisterTargetMachine<BPFTargetMachine> X(getTheBPFleTarget());
  33   RegisterTargetMachine<BPFTargetMachine> Y(getTheBPFbeTarget());
  34   RegisterTargetMachine<BPFTargetMachine> Z(getTheBPFTarget());
  35
  36   PassRegistry &PR = *PassRegistry::getPassRegistry();
  37   initializeBPFAbstractMemberAccessPass(PR);
  38   initializeBPFMIPeepholePass(PR);
  39 }
  40
  41 // DataLayout: little or big endian
  42 static std::string computeDataLayout(const Triple &TT) {
  43   if (TT.getArch() == Triple::bpfeb)
  44     return "E-m:e-p:64:64-i64:64-n32:64-S128";
  45   else
  46     return "e-m:e-p:64:64-i64:64-n32:64-S128";
  47 }
  48
  49 static Reloc::Model getEffectiveRelocModel(Optional<Reloc::Model> RM) {
  50   if (!RM.hasValue())
  51     return Reloc::PIC_;
  52   return *RM;
  53 }
  54
  55 BPFTargetMachine::BPFTargetMachine(const Target &T, const Triple &TT,
  56                                    StringRef CPU, StringRef FS,
  57                                    const TargetOptions &Options,
  58                                    Optional<Reloc::Model> RM,
  59                                    Optional<CodeModel::Model> CM,
  60                                    CodeGenOpt::Level OL, bool JIT)
  61     : LLVMTargetMachine(T, computeDataLayout(TT), TT, CPU, FS, Options,
  62                         getEffectiveRelocModel(RM),
  63                         getEffectiveCodeModel(CM, CodeModel::Small), OL),
  64       TLOF(std::make_unique<TargetLoweringObjectFileELF>()),
  65       Subtarget(TT, CPU, FS, *this) {
  66   initAsmInfo();
  67
  68   BPFMCAsmInfo *MAI =
  69       static_cast<BPFMCAsmInfo *>(const_cast<MCAsmInfo *>(AsmInfo.get()));
  70   MAI->setDwarfUsesRelocationsAcrossSections(!Subtarget.getUseDwarfRIS());
  71 }
  72
  73 namespace {
  74 // BPF Code Generator Pass Configuration Options.
  75 class BPFPassConfig : public TargetPassConfig {
  76 public:
  77   BPFPassConfig(BPFTargetMachine &TM, PassManagerBase &PM)
  78       : TargetPassConfig(TM, PM) {}
  79
  80   BPFTargetMachine &getBPFTargetMachine() const {
  81     return getTM<BPFTargetMachine>();
  82   }
  83
  84   void addIRPasses() override;
  85   bool addInstSelector() override;
  86   void addMachineSSAOptimization() override;
  87   void addPreEmitPass() override;
  88 };
  89 }
  90
  91 TargetPassConfig *BPFTargetMachine::createPassConfig(PassManagerBase &PM) {
  92   return new BPFPassConfig(*this, PM);
  93 }
  94
  95 void BPFPassConfig::addIRPasses() {
  96
  97   addPass(createBPFAbstractMemberAccess(&getBPFTargetMachine()));
  98
  99   TargetPassConfig::addIRPasses();
 100 }
 101
 102 // Install an instruction selector pass using
 103 // the ISelDag to gen BPF code.
 104 bool BPFPassConfig::addInstSelector() {
 105   addPass(createBPFISelDag(getBPFTargetMachine()));
 106
 107   return false;
 108 }
 109
 110 void BPFPassConfig::addMachineSSAOptimization() {
 111   addPass(createBPFMISimplifyPatchablePass());
 112
 113   // The default implementation must be called first as we want eBPF
 114   // Peephole ran at last.
 115   TargetPassConfig::addMachineSSAOptimization();
 116
 117   const BPFSubtarget *Subtarget = getBPFTargetMachine().getSubtargetImpl();
 118   if (Subtarget->getHasAlu32() && !DisableMIPeephole)
 119     addPass(createBPFMIPeepholePass());
 120 }
 121
 122 void BPFPassConfig::addPreEmitPass() {
 123   const BPFSubtarget *Subtarget = getBPFTargetMachine().getSubtargetImpl();
 124
 125   addPass(createBPFMIPreEmitCheckingPass());
 126   if (getOptLevel() != CodeGenOpt::None)
 127     if (Subtarget->getHasAlu32() && !DisableMIPeephole)
 128       addPass(createBPFMIPreEmitPeepholePass());
 129 }