Improve documentation

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
 //
 //===----------------------------------------------------------------------===//
 ///
-/// \file Function pass to verify all functions are in program memory
+/// \file
+/// Function pass to verify all functions are in program memory
 ///
 /// Visits all functions in a module and reports those that are not in the
-/// program memory address space.
+/// program memory address space as defined by the targets DataLayout. This
+/// helps to find transformations that accidentially place functions in data
+/// space because they assume a von Neumann architecture.
 ///
 /// Usage:
 /// \code
 /// opt -load libHarvardCheck.dylib --harvard-check --harvard-abort-on-error
 /// \endcode
 ///
 /// \param --harvard-abort-on-error
-/// \param --harvard-program-address-space N
+/// \param --harvard-program-address-space NUMBER
 ///
 //===----------------------------------------------------------------------===//
 
 #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>
     ProgramAddressSpaceOption("harvard-program-address-space", cl::init(-1),
                               cl::desc("override program address space"));
 
 static cl::opt<bool> AbortOnErrorOption("harvard-abort-on-error",
                                         cl::init(false),
                                         cl::desc("abort on error"));
 
 namespace {
 
-struct HarvardCheck : FunctionPass {
+class HarvardCheck : public FunctionPass {
+public:
   static char ID;
   HarvardCheck() : FunctionPass(ID), ProgramAddressSpace(), ErrorCount() {}
 
   bool doInitialization(Module &M) override {
     ProgramAddressSpace = ProgramAddressSpaceOption == -1
                               ? M.getDataLayout().getProgramAddressSpace()
                               : ProgramAddressSpaceOption;
     ModuleName = M.getName();
if (F.getAddressSpace() != ProgramAddressSpace) {
              << "\n";
       ++ErrorCount;
     }
     return false;
   }
 
   bool doFinalization(Module &) override {
     if (ErrorCount != 0 && AbortOnErrorOption) {
-      errs() << "not all functions are in program memory. Aborting\n";
+      errs() << "error: not all functions are in program memory. Aborting\n";
       exit(1);
     }
     return false;
   }
 
 private:
   unsigned ProgramAddressSpace;
   unsigned ErrorCount;