[llvm-exegesis] InMemoryAssembler: handle return-less targets (e.g. arm).

[courbet]

Summary

Arm does not have a ret code per se.

[gchatelet]

unittests/tools/llvm-exegesis/ARM/InMemoryAssemblerTest.cpp

70

Can you format this better?

[courbet]

clang-format

tools/llvm-exegesis/lib/CMakeLists.txt

add_library(LLVMExegesis
   )
 
 llvm_update_compile_flags(LLVMExegesis)
 llvm_map_components_to_libnames(libs
   Analysis
   CodeGen
   Core
   ExecutionEngine
+  GlobalISel
   MC
   MCJIT
   Object
   Support
   )
 
 target_link_libraries(LLVMExegesis ${libs})
 set_target_properties(LLVMExegesis PROPERTIES FOLDER "Libraries")

tools/llvm-exegesis/lib/InMemoryAssembler.cpp

 //===-- InMemoryAssembler.cpp -----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "InMemoryAssembler.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/CodeGen/GlobalISel/CallLowering.h"
+#include "llvm/CodeGen/GlobalISel/MachineIRBuilder.h"
 #include "llvm/CodeGen/MachineInstrBuilder.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/CodeGen/TargetInstrInfo.h"
 #include "llvm/CodeGen/TargetPassConfig.h"
 #include "llvm/ExecutionEngine/ExecutionEngine.h"
 #include "llvm/ExecutionEngine/MCJIT.h"
 #include "llvm/ExecutionEngine/SectionMemoryManager.h"
for (unsigned OpIndex = 0, E = Inst.getNumOperands(); OpIndex < E;
         Builder.addReg(Op.getReg(), Flags);
       } else if (Op.isImm()) {
         Builder.addImm(Op.getImm());
       } else {
         llvm_unreachable("Not yet implemented");
       }
     }
   }
-  // Adding the Return Opcode.
+  // Insert the return code.
   const llvm::TargetInstrInfo *TII = MF.getSubtarget().getInstrInfo();
+  if (TII->getReturnOpcode() < TII->getNumOpcodes()) {
     llvm::BuildMI(MBB, DL, TII->get(TII->getReturnOpcode()));
+  } else {
+    llvm::MachineIRBuilder MIB(MF);
+    MIB.setMBB(*MBB);
+    MF.getSubtarget().getCallLowering()->lowerReturn(MIB, nullptr, 0);
+  }
 }
 
 namespace {
 
 // Implementation of this class relies on the fact that a single object with a
 // single function will be loaded into memory.
 class TrackingSectionMemoryManager : public llvm::SectionMemoryManager {
 public:

unittests/tools/llvm-exegesis/ARM/CMakeLists.txt

+include_directories(
+  ${LLVM_MAIN_SRC_DIR}/lib/Target/ARM
+  ${LLVM_BINARY_DIR}/lib/Target/ARM
+  ${LLVM_MAIN_SRC_DIR}/tools/llvm-exegesis/lib
+  )
+
+set(LLVM_LINK_COMPONENTS
+  MC
+  MCParser
+  Object
+  Support
+  Symbolize
+  ARM
+  )
+
+add_llvm_unittest(LLVMExegesisARMTests
+  InMemoryAssemblerTest.cpp
+  )
+target_link_libraries(LLVMExegesisARMTests PRIVATE LLVMExegesis)
+

unittests/tools/llvm-exegesis/ARM/InMemoryAssemblerTest.cpp

+//===-- InMemoryAssemblerTest.cpp -------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "InMemoryAssembler.h"
+#include "ARMInstrInfo.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/CodeGen/MachineInstrBuilder.h"
+#include "llvm/CodeGen/TargetInstrInfo.h"
+#include "llvm/CodeGen/TargetSubtargetInfo.h"
+#include "llvm/MC/MCInstBuilder.h"
+#include "llvm/Support/Host.h"
+#include "llvm/Support/TargetRegistry.h"
+#include "llvm/Support/TargetSelect.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include <memory>
+
+namespace exegesis {
+namespace {
+
+using llvm::MCInstBuilder;
+using testing::ElementsAre;
+
+class MachineFunctionGeneratorTest : public ::testing::Test {
+protected:
+  MachineFunctionGeneratorTest()
+      : TT("armv7-none-linux-gnueabi"),
+        CpuName("") {}
+
+  static void SetUpTestCase() {
+    LLVMInitializeARMTargetInfo();
+    LLVMInitializeARMTargetMC();
+    LLVMInitializeARMTarget();
+    LLVMInitializeARMAsmPrinter();
+  }
+
+  std::unique_ptr<llvm::LLVMTargetMachine> createTargetMachine() {
+    std::string Error;
+    const llvm::Target *TheTarget =
+        llvm::TargetRegistry::lookupTarget(TT, Error);
+    assert(TheTarget);
+    const llvm::TargetOptions Options;
+    return std::unique_ptr<llvm::LLVMTargetMachine>(
+        static_cast<llvm::LLVMTargetMachine *>(TheTarget->createTargetMachine(
+            TT, CpuName, "", Options, llvm::Reloc::Model::Static)));
+  }
+
+private:
+  const std::string TT;
+  const std::string CpuName;
+};
+
+TEST_F(MachineFunctionGeneratorTest, JitFunction) {
+  JitFunctionContext Context(createTargetMachine());
+  JitFunction Function(std::move(Context), {});
+  ASSERT_THAT(Function.getFunctionBytes().str(),
+              ElementsAre(0x1e, 0xff, 0x2f, 0xe1));
+}
+
+TEST_F(MachineFunctionGeneratorTest, JitFunctionADDrr) {
+  JitFunctionContext Context(createTargetMachine());
+  JitFunction Function(
+      std::move(Context),
+      {MCInstBuilder(llvm::ARM::ADDrr).addReg(llvm::ARM::R0).addReg(llvm::ARM::R0).addReg(llvm::ARM::R0).addImm(llvm::ARMCC::AL).addReg(0).addReg(0)});
+  ASSERT_THAT(Function.getFunctionBytes().str(), ElementsAre(0x00, 0x00, 0x80, 0xe0, 0x1e, 0xff, 0x2f, 0xe1));
+}
+
+} // namespace
+} // namespace exegesis

unittests/tools/llvm-exegesis/CMakeLists.txt

add_llvm_unittest(LLVMExegesisTests
   )
 target_link_libraries(LLVMExegesisTests PRIVATE LLVMExegesis)
 
 if(LLVM_ENABLE_LIBPFM AND HAVE_LIBPFM)
   target_link_libraries(LLVMExegesisTests PRIVATE pfm)
 endif()
 
 if(LLVM_TARGETS_TO_BUILD MATCHES "X86")
-  add_subdirectory(
-    X86
-  )
+  add_subdirectory(X86)
+endif()
+if(LLVM_TARGETS_TO_BUILD MATCHES "ARM")
+  add_subdirectory(ARM)
 endif()