AVR Backend: Add harvard program address space checker pass

[agnat2]

Summary

Add a pass to verify that all functions ended up in the
program address space.

[agnat2]

Fix format.

[dylanmckay]

Patch is looking really good, only suggestions are the adding a test and a couple formatting nitpicks.

llvm/lib/Target/AVR/HarvardCheck/CMakeLists.txt

1

Add the prefix AVR to the library name, i.e. libAVRHarvardCheck to make it clear this dylib is a part of the AVR backend.

llvm/lib/Target/AVR/HarvardCheck/HarvardCheck.cpp

73

Remove the m_ prefix from the member field names, as LLVM doesn't use this naming convention.

82

Add a test for the new pass, inside test/CodeGen/AVR for the new pass. The RUN: line can be ; RUN: opt -load libHarvardCheck.dylib --harvard-check -march=avr 2>&1 < %s | FileCheck %s, the test can contain functions in the wrong address space, and the CHECK lines can verify that the correct error messages are generated.

llvm/lib/Target/AVR/CMakeLists.txt

add_llvm_target(AVRCodeGen
   AVRTargetObjectFile.cpp
 
   DEPENDS
   intrinsics_gen
 )
 
 add_subdirectory(AsmParser)
 add_subdirectory(Disassembler)
+add_subdirectory(HarvardCheck)
 add_subdirectory(MCTargetDesc)
 add_subdirectory(TargetInfo)

llvm/lib/Target/AVR/HarvardCheck/CMakeLists.txt

+add_llvm_library(libHarvardCheck MODULE
+  HarvardCheck.cpp
+
+  PLUGIN_TOOL
+  opt
+)
+

llvm/lib/Target/AVR/HarvardCheck/HarvardCheck.cpp

+//===-- HarvardCheck.cpp - Check Function Address Space -------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Visits all functions in a module and reports those that are not in the
+// program memory address space.
+//
+// Usage:
+// opt -load libHarvardCheck.dylib --harvard-check
+// opt -load libHarvardCheck.dylib --harvard-check --harvard-abort-on-error
+// opt -load libHarvardCheck.dylib --harvard-check
+// --harvard-program-address-space 5
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/IR/Function.h"
+#include "llvm/IR/LegacyPassManager.h"
+#include "llvm/Pass.h"
+#include "llvm/Passes/PassBuilder.h"
+#include "llvm/Passes/PassPlugin.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/Transforms/IPO/PassManagerBuilder.h"
+
+using namespace llvm;
+
+static cl::opt<int>
+    ProgramAddressSpace("harvard-program-address-space", cl::init(-1),
+                        cl::desc("override program address space"));
+
+static cl::opt<bool> AbortOnError("harvard-abort-on-error", cl::init(false),
+                                  cl::desc("abort on error"));
+
+namespace {
+
+struct HarvardCheck : FunctionPass {
+  static char ID;
+  HarvardCheck() : FunctionPass(ID), m_programAddressSpace(), m_errorCount() {}
+
+  bool doInitialization(Module &M) override {
+    if (ProgramAddressSpace == -1) {
+      m_programAddressSpace = M.getDataLayout().getProgramAddressSpace();
+    } else {
+      m_programAddressSpace = ProgramAddressSpace;
+    }
+    return false;
+  }
+
+  bool runOnFunction(Function &F) override {
+    if (F.getAddressSpace() != m_programAddressSpace) {
+      errs() << "harvard check: Function '";
+      errs().write_escaped(F.getName()) << "' is not in program memory. "
+                                           "Expected address space "
+                                        << m_programAddressSpace << ", but got "
+                                        << F.getAddressSpace() << ".\n";
+      ++m_errorCount;
+    }
+    return false;
+  }
+
+  bool doFinalization(Module &) override {
+    if (m_errorCount != 0 && AbortOnError) {
+      errs() << "harvard check: Aborting.\n";
+      exit(1);
+    }
+    return false;
+  }
+
+private:
+  unsigned m_programAddressSpace;
+  unsigned m_errorCount;
+}; // end of struct HarvardCheck
+
+} // end of anonymous namespace
+
+char HarvardCheck::ID = 0;
+
+static RegisterPass<HarvardCheck>
+    X("harvard-check", "Verify that all code resides in program memory", false,
+      false);
+
+static RegisterStandardPasses Y(PassManagerBuilder::EP_OptimizerLast,
+                                [](const PassManagerBuilder &Builder,
+                                   legacy::PassManagerBase &PM) {
+                                  PM.add(new HarvardCheck());
+                                });