Added initial boilerplate for Call Lowering [M68k GlobaliSel]

[myhsu]

It's fine to put unfinished work here :-) Just mark it as a draft

llvm/lib/Target/M68k/CMakeLists.txt

 add_llvm_component_group(M68k)
 
 set(LLVM_TARGET_DEFINITIONS M68k.td)
 
 tablegen(LLVM M68kGenRegisterInfo.inc     -gen-register-info)
 tablegen(LLVM M68kGenInstrInfo.inc        -gen-instr-info)
 tablegen(LLVM M68kGenSubtargetInfo.inc    -gen-subtarget)
 tablegen(LLVM M68kGenMCCodeBeads.inc      -gen-code-beads)
+tablegen(LLVM M68kGenGlobalISel.inc       -gen-global-isel)
 tablegen(LLVM M68kGenMCPseudoLowering.inc -gen-pseudo-lowering)
+tablegen(LLVM M68kGenRegisterBank.inc     -gen-register-bank)
 tablegen(LLVM M68kGenDAGISel.inc          -gen-dag-isel)
 tablegen(LLVM M68kGenCallingConv.inc      -gen-callingconv)
 tablegen(LLVM M68kGenAsmWriter.inc        -gen-asm-writer)
 tablegen(LLVM M68kGenAsmMatcher.inc       -gen-asm-matcher)
 
 add_public_tablegen_target(M68kCommonTableGen)
 
 add_llvm_target(M68kCodeGen
   M68kAsmPrinter.cpp
+  M68kCallLowering.cpp
   M68kCollapseMOVEMPass.cpp
   M68kExpandPseudo.cpp
   M68kFrameLowering.cpp
   M68kInstrInfo.cpp
+  M68kInstructionSelector.cpp
   M68kISelLowering.cpp
+  M68kLegalizerInfo.cpp
   M68kISelDAGToDAG.cpp
   M68kMachineFunction.cpp
   M68kMCInstLower.cpp
+  M68kRegisterBankInfo.cpp
   M68kRegisterInfo.cpp
   M68kSubtarget.cpp
   M68kTargetMachine.cpp
   M68kTargetObjectFile.cpp
 
   LINK_COMPONENTS
+  GlobalISel
   Analysis
   AsmPrinter
   CodeGen
   Core
   MC
   SelectionDAG
   Support
   Target
   M68kDesc
   M68kInfo
   
   ADD_TO_COMPONENT
   M68k
 )
 
 add_subdirectory(TargetInfo)
 add_subdirectory(MCTargetDesc)
 add_subdirectory(AsmParser)
 add_subdirectory(Disassembler)

llvm/lib/Target/M68k/M68k.h

 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_TARGET_M68K_M68K_H
 #define LLVM_LIB_TARGET_M68K_M68K_H
 
 namespace llvm {
 
+class M68kRegisterBankInfo;
+class M68kSubtarget;
 class FunctionPass;
+class InstructionSelector;
 class M68kTargetMachine;
 
 /// This pass converts a legalized DAG into a M68k-specific DAG, ready for
 /// instruction scheduling.
 FunctionPass *createM68kISelDag(M68kTargetMachine &TM);
 
 /// Return a Machine IR pass that expands M68k-specific pseudo
 /// instructions into a sequence of actual instructions. This pass

 
 /// Finds MOVE instructions before any conditioanl branch instruction and
 /// replaces them with MOVEM instruction. Motorola's MOVEs do trash(V,C) flags
 /// register which prevents branch from taking the correct route. This pass
 /// has to be run after all pseudo expansions and prologue/epilogue emission
 /// so that all possible MOVEs are present.
 FunctionPass *createM68kConvertMOVToMOVMPass();
 
+InstructionSelector *createM68kInstructionSelector(const M68kTargetMachine &,
+                                                    M68kSubtarget &,
+                                                    M68kRegisterBankInfo &);
+
 } // namespace llvm
 
 #endif

llvm/lib/Target/M68k/M68kCallLowering.h

+//===-- M68kCallLowering.h - Call lowering ---------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+/// \file
+/// This file describes how to lower LLVM calls to machine code calls.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_TARGET_M68K_M68KCALLLOWERING_H
+#define LLVM_LIB_TARGET_M68K_M68KCALLLOWERING_H
+
+#include "llvm/CodeGen/CallingConvLower.h"
+#include "llvm/CodeGen/GlobalISel/CallLowering.h"
+#include "llvm/CodeGen/ValueTypes.h"
+
+namespace llvm {
+
+class M68kTargetLowering;
+
+class M68kCallLowering : public CallLowering {
+
+public:
+  M68kCallLowering(const M68kTargetLowering &TLI);
+
+  bool lowerReturn(MachineIRBuilder &MIRBuilder, const Value *Val,
+                   ArrayRef<Register> VRegs, FunctionLoweringInfo &FLI,
+                   Register SwiftErrorVReg) const override;
+
+  bool lowerFormalArguments(MachineIRBuilder &MIRBuilder, const Function &F,
+                            ArrayRef<ArrayRef<Register>> VRegs,
+                            FunctionLoweringInfo &FLI) const override;
+
+  bool lowerCall(MachineIRBuilder &MIRBuilder,
+                 CallLoweringInfo &Info) const override;
+};
+
+} // end namespace llvm
+
+#endif // LLVM_LIB_TARGET_M68k_M68kCALLLOWERING_H
 No newline at end of file

llvm/lib/Target/M68k/M68kCallLowering.cpp

+//===-- M68kCallLowering.cpp - Call lowering -------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+/// \file
+/// This file implements the lowering of LLVM calls to machine code calls for
+/// GlobalISel.
+//
+//===----------------------------------------------------------------------===//
+
+#include "M68kCallLowering.h"
+#include "M68kISelLowering.h"
+#include "llvm/CodeGen/GlobalISel/MachineIRBuilder.h"
+
+using namespace llvm;
+
+M68kCallLowering::M68kCallLowering(const M68kTargetLowering &TLI)
+    : CallLowering(&TLI) {}
+
+bool M68kCallLowering::lowerReturn(MachineIRBuilder &MIRBuilder,
+                                    const Value *Val,
+                                    ArrayRef<Register> VRegs,
+                                    FunctionLoweringInfo &FLI,
+                                    Register SwiftErrorVReg) const {
+
+  MachineInstrBuilder Ret = MIRBuilder.buildInstrNoInsert(M68k::RET);
+
+  if (Val != nullptr) {
+    return false;
+  }
+  MIRBuilder.insertInstr(Ret);
+  return true;
+}
+
+bool M68kCallLowering::lowerFormalArguments(
+    MachineIRBuilder &MIRBuilder, const Function &F,
+    ArrayRef<ArrayRef<Register>> VRegs,FunctionLoweringInfo &FLI) const {
+
+  if (F.arg_empty())
+    return true;
+
+  return false;
+}
+
+bool M68kCallLowering::lowerCall(MachineIRBuilder &MIRBuilder,
+                                  CallLoweringInfo &Info) const {
+  return false;
+}
 No newline at end of file

llvm/lib/Target/M68k/M68kSubtarget.cpp

 //===-- M68kSubtarget.cpp - M68k Subtarget Information ------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file implements the M68k specific subclass of TargetSubtargetInfo.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "M68kSubtarget.h"
 
 #include "M68k.h"
+#include "M68kCallLowering.h"
+#include "M68kFrameLowering.h"
+#include "M68kLegalizerInfo.h"
+#include "M68kRegisterBankInfo.h"
 #include "M68kMachineFunction.h"
 #include "M68kRegisterInfo.h"
 #include "M68kTargetMachine.h"
 
 #include "llvm/CodeGen/MachineJumpTableInfo.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
unsigned M68kSubtarget::getJumpTableEncoding() const {
   return MachineJumpTableInfo::EK_BlockAddress;
 }
 
 unsigned char
 M68kSubtarget::classifyGlobalFunctionReference(const GlobalValue *GV) const {
   return classifyGlobalFunctionReference(GV, *GV->getParent());
 }
 
+const CallLowering *M68kSubtarget::getCallLowering() const {
+  return CallLoweringInfo.get();
+}
+
+InstructionSelector *M68kSubtarget::getInstructionSelector() const {
+  return InstSelector.get();
+}
+
+const LegalizerInfo *M68kSubtarget::getLegalizerInfo() const {
+  return Legalizer.get();
+}
+
+const RegisterBankInfo *M68kSubtarget::getRegBankInfo() const {
+  return RegBankInfo.get();
+}
+
 unsigned char
 M68kSubtarget::classifyGlobalFunctionReference(const GlobalValue *GV,
                                                const Module &M) const {
   // local always use pc-rel referencing
   if (TM.shouldAssumeDSOLocal(M, GV))
     return M68kII::MO_NO_FLAG;
 
   // If the function is marked as non-lazy, generate an indirect call

llvm/lib/Target/M68k/M68kTargetMachine.cpp

 //===-- M68kTargetMachine.cpp - M68k target machine ---------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file contains implementation for M68k target machine.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "M68kTargetMachine.h"
 #include "M68k.h"
 #include "TargetInfo/M68kTargetInfo.h"
-
+#include "llvm/CodeGen/GlobalISel/IRTranslator.h"
+#include "llvm/CodeGen/GlobalISel/InstructionSelect.h"
+#include "llvm/CodeGen/GlobalISel/Legalizer.h"
+#include "llvm/CodeGen/GlobalISel/RegBankSelect.h"
 #include "M68kSubtarget.h"
 #include "M68kTargetObjectFile.h"
 
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/CodeGen/TargetPassConfig.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/Support/TargetRegistry.h"
 #include <memory>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "m68k"
 
 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeM68kTarget() {
   RegisterTargetMachine<M68kTargetMachine> X(getTheM68kTarget());
+  auto *PR = PassRegistry::getPassRegistry();
+  initializeGlobalISel(*PR);
 }
 
 namespace {
 
 std::string computeDataLayout(const Triple &TT, StringRef CPU,
                               const TargetOptions &Options) {
   std::string Ret = "";
   // M68k is Big Endian
public:
   M68kTargetMachine &getM68kTargetMachine() const {
     return getTM<M68kTargetMachine>();
   }
 
   const M68kSubtarget &getM68kSubtarget() const {
     return *getM68kTargetMachine().getSubtargetImpl();
   }
 
+  bool addIRTranslator() override;
+  bool addLegalizeMachineIR() override;
+  bool addRegBankSelect() override;
+  bool addGlobalInstructionSelect() override;
   bool addInstSelector() override;
   void addPreSched2() override;
   void addPreEmitPass() override;
 };
 } // namespace
 
 TargetPassConfig *M68kTargetMachine::createPassConfig(PassManagerBase &PM) {
   return new M68kPassConfig(*this, PM);