OptionPlugin.hpp

Go to the documentation of this file.

/*
*    MIT License
*    
*    Copyright (c) 2021 Amano laboratory, Keio University & Processor Research Team, RIKEN Center for Computational Science
*    
*    Permission is hereby granted, free of charge, to any person obtaining a copy of
*    this software and associated documentation files (the "Software"), to deal in
*    the Software without restriction, including without limitation the rights to
*    use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
*    of the Software, and to permit persons to whom the Software is furnished to do
*    so, subject to the following conditions:
*    
*    The above copyright notice and this permission notice shall be included in all
*    copies or substantial portions of the Software.
*    
*    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
*    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
*    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
*    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
*    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
*    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
*    SOFTWARE.
*    
*    File:          /include/OptionPlugin.hpp
*    Project:       CGRAOmp
*    Author:        Takuya Kojima in The University of Tokyo (tkojima@hal.ipc.i.u-tokyo.ac.jp)
*    Created Date:  27-08-2021 14:20:02
*    Last Modified: 17-07-2022 19:59:36
*/
#ifndef OptionPlugin_H
#define OptionPlugin_H
 
#include "llvm/Support/CommandLine.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/Support/FormatVariadic.h"
#include "llvm/Support/raw_ostream.h"
 
#include <regex>
#include <string>
 
using namespace llvm;
using namespace std;
 
namespace CGRAOmp
{
    class OptKeyValue {
        public:
            OptKeyValue() : key(""), value(""), valid(false) {}
            OptKeyValue(string key, string value) :
                key(key), value(value), valid(true) {};
            OptKeyValue(const char* s) : OptKeyValue(string(s)) {}
            OptKeyValue(string keyvalue);
 
            OptKeyValue(const OptKeyValue &) = default;
            OptKeyValue(OptKeyValue &&) = default;
 
            pair<string, string> get() {
                return make_pair(key, value);
            }
 
            string get_key() const {
                return key;
            }
 
            string get_value() const {
                return value;
            }
 
            explicit operator bool() const noexcept {
                return valid;
            }
 
            bool operator!=(const OptKeyValue &rhs) {
                return !(*this == rhs);
            }
 
            bool operator==(const OptKeyValue &rhs) {
                return (key == rhs.key) && (value == rhs.value);
            }
 
            OptKeyValue& operator=(OptKeyValue &&r) = default;
            OptKeyValue& operator=(const OptKeyValue &r) = default;
 
        private:
            bool valid;
            string key;
            string value;
    };
 
    extern cl::opt<string> PathToCGRAConfig;
    extern cl::alias PathToCGRAConfigAlias;
 
    extern cl::opt<bool> OptVerbose;
    extern cl::opt<string> OptDFGOpKey;
    extern cl::opt<bool> OptDFGPlainNodeName;
 
    extern cl::list<OptKeyValue> OptDFGGraphProp;
    extern cl::list<OptKeyValue> OptDFGNodeProp;
    extern cl::list<OptKeyValue> OptDFGEdgeProp;
 
    extern cl::opt<int> OptDFGFloatPrecWidth;
    
    extern cl::list<string> OptDFGPassPipeline;
 
    extern cl::list<string> OptDFGPassPlugin;
 
    extern cl::opt<string> OptDFGFilePrefix;
 
    extern cl::opt<bool> OptLoopInvariantAsConstant;
 
    extern cl::opt<bool> OptUseSimpleDFGName;
 
    extern cl::opt<int> OptMemoryDependencyDistanceThreshold;
 
    extern cl::opt<bool> OptEnableLoopFlatten;
 
 
 
}
 
namespace llvm {
 
raw_ostream& operator<<(raw_ostream &OS, const CGRAOmp::OptKeyValue &D);
 
namespace cl {
 
using namespace CGRAOmp;
 
bool operator==(const OptKeyValue &lhs, const OptKeyValue &rhs);
bool operator!=(const OptKeyValue &lhs, const OptKeyValue &rhs);
 
template <>
struct OptionValue<OptKeyValue> final : OptionValueCopy<OptKeyValue> {
  using WrapperType = OptKeyValue;
 
  OptionValue() = default;
 
  OptionValue(const OptKeyValue &V) { this->setValue(V); }
 
  OptionValue<OptKeyValue> &operator=(const OptKeyValue &V) {
    setValue(V);
    return *this;
  }
 
private:
  void anchor() override;
};
 
template <> class parser<OptKeyValue> : public basic_parser<OptKeyValue> {
    public:
        parser(Option &O) : basic_parser(O) {}
 
        // parse - Return true on error.
        bool parse(Option &O, StringRef, StringRef Arg, OptKeyValue &Value) {
            Value = OptKeyValue(Arg.str());
            if (!Value) {
                return O.error("'" + Arg +
                            "' value invalid for key-value argument!");
            }
            return false;
        }
 
        // getValueName - Overload in subclass to provide a better default value.
        StringRef getValueName() const override { return "key=value"; }
 
        void printOptionDiff(const Option &O, const OptVal &V, const OptVal &Default, size_t GlobalWidth) const;
 
        // An out-of-line virtual method to provide a 'home' for this class.
        void anchor() override;
};
 
extern template class basic_parser<OptKeyValue>;
 
} // end namespace cl
 
} // end namespace llvm
 
#endif //OptionPlugin_H