CGRAInstMap.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/CGRAInstMap.hpp
*    Project:       CGRAOmp
*    Author:        Takuya Kojima in The University of Tokyo (tkojima@hal.ipc.i.u-tokyo.ac.jp)
*    Created Date:  05-09-2021 18:35:11
*    Last Modified: 17-02-2022 21:38:52
*/
 
#ifndef CGRAInstMap_H
#define CGRAInstMap_H
 
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/IR/Constant.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/InstrTypes.h"
#include "llvm/IR/Instruction.h"
#include "llvm/IR/Operator.h"
#include "llvm/Support/JSON.h"
#include "llvm/IR/PassManager.h"
 
#include "common.hpp"
#include "CGRAOmpAnnotationPass.hpp"
 
 
#include <float.h>
#include <math.h>
 
#define CGRAOMP_CUSTOM_INST_ATTR "cgra_custom_inst"
 
 
#define FLAG_GETTER(FLAG, ISA, GETTER) make_pair(FLAG, [](Instruction *I) { \
    if (isa<ISA>(I)) { \
        return I->GETTER(); \
    } else { \
        return false;\
    } \
})
 
#define CMP_PRED_PAIR(STR, ENUM) make_pair(STR, CmpInst::Predicate::ENUM)
 
 
#define BINOP_ENTRY(OPCODE, OPENUM) make_pair(OPCODE, [](MapCondition *c){ \
    if (c) { \
        return make_shared<BinaryOpMapEntry>(OPCODE, BinaryOperator::OPENUM, c); \
    } else { \
        return make_shared<BinaryOpMapEntry>(OPCODE, BinaryOperator::OPENUM); \
    }\
})
#define COMPOP_ENTRY(OPCODE, IS_INTEGER) make_pair(OPCODE, [](MapCondition *c){ \
    if (c) { \
        return make_shared<CompOpMapEntry>(OPCODE, IS_INTEGER, c); \
    } else { \
        return make_shared<CompOpMapEntry>(OPCODE, IS_INTEGER); \
    }\
})
#define MEMOP_ENTRY(OPCODE, OPENUM) make_pair(OPCODE, [](MapCondition *c){ \
    if (c) { \
        return make_shared<MemoryOpMapEntry>(OPCODE, Instruction::MemoryOps::OPENUM, c); \
    } else { \
        return make_shared<MemoryOpMapEntry>(OPCODE, Instruction::MemoryOps::OPENUM); \
    }\
})
 
#define OTHEROP_ENTRY(OPCODE, OPENUM) make_pair(OPCODE, [](MapCondition *c){ \
    if (c) { \
        return make_shared<OtherOpMapEntry>(OPCODE, OPENUM, c); \
    } else { \
        return make_shared<OtherOpMapEntry>(OPCODE, OPENUM); \
    }\
})
 
// Key setting to parse the JSON object
#define INST_KEY        "inst"
#define MAP_KEY         "map"
#define CONST_RHS_KEY   "rhs"
#define CONST_LHS_KEY   "lhs"
#define FLAGS_KEY       "flags"
#define PRED_KEY        "pred"
#define CONST_INT_KEY   "ConstantInt"
#define CONST_DBL_KEY   "ConstantDouble"
 
#define VEC_MAKE_RANGE(VEC) (make_range(VEC.begin(), VEC.end()))
 
using namespace llvm;
 
 
namespace CGRAOmp
{
    class MapCondition {
        public:
            MapCondition(StringRef map) :
                map_name(map.str()), anyLHS(true),
                anyRHS(true), anyPred(true) {};
            MapCondition(const MapCondition &) = default;
            MapCondition(MapCondition &&) = default;
 
            ~MapCondition(){}
 
            void setConst(int use, bool isLeft);
 
            void setConst(double use, bool isLeft);
 
            Error setFlags(ArrayRef<std::string>  flags);
 
            Error setPred(StringRef pred);
 
            bool match(Instruction *I);
 
            std::string getMapName() {
                return map_name;
            }
 
            void print(raw_ostream &OS);
 
            void dump() {
                print(errs());
                errs() << "\n";
            }
        private:
            std::function<bool(Instruction*I)> match_use;
 
            std::string map_name;
            int use_int;
            double use_double;
            SmallVector<StringRef> flag_list;
            CmpInst::Predicate cmp_pred;
            bool isUseInt = false;
            bool anyLHS;
            bool anyRHS;
            bool anyPred;
            int const_operand;
 
            StringRef pred_str;
 
            static bool equal_double(double a, double b) {
                return (fabs(a - b) <= DBL_EPSILON
                    * fmax(1, fmax(fabs(a), fabs(b))));
            }
 
            static StringMap<std::function<bool(Instruction*)>> FlagGetter;
            static StringMap<CmpInst::Predicate> PredMap;
 
    };
 
    Expected<std::pair<StringRef,MapCondition*>> createMapCondition(
                                                json::Object *json_obj,
                                                StringRef filename);
 
    Expected<SmallVector<std::string>> getStringArray(json::Object *json_obj,
                                    StringRef key, StringRef filename);
 
    class InstMapEntry {
        public:
            enum class InstMapKind {
                BinaryOp,
                CompOp,
                MemOp,
                CustomOp,
                OtherOp
            };
 
            InstMapEntry(StringRef opcode, InstMapKind Kind) :
                opcode_str(opcode.str()), Kind(Kind) {
                    map_cond = new MapCondition(opcode);
            };
 
            InstMapEntry(StringRef opcode, InstMapKind Kind, MapCondition* cond) :
                opcode_str(opcode.str()), Kind(Kind), map_cond(cond) {};
 
            ~InstMapEntry() {
                delete map_cond;
            }
 
            void addMapping(MapCondition* cond) {
                map_cond = cond;
            }
 
            virtual bool match(Instruction *I) = 0;
            virtual bool match(StringRef opcode) {
                return opcode_str == opcode;
            };
 
            virtual std::string getMapName() {
                return map_cond->getMapName();
            }
 
            void print(raw_ostream &OS);
            void dump() {
                print(errs());
                errs() << "\n";
            }
 
            InstMapKind getKind() const {
                return Kind;
            }
        private:
            InstMapKind Kind;
        protected:
            MapCondition* map_cond;
            std::string opcode_str;
 
 
    };
 
    class BinaryOpMapEntry : public InstMapEntry {
        public:
            static constexpr InstMapEntry::InstMapKind BinaryOp =
                 InstMapEntry::InstMapKind::BinaryOp;
            BinaryOpMapEntry(StringRef opcode, Instruction::BinaryOps ops) :
                InstMapEntry(opcode, BinaryOp), ops(ops) {};
 
            BinaryOpMapEntry(StringRef opcode, Instruction::BinaryOps ops,
                                MapCondition* cond) :
                InstMapEntry(opcode, BinaryOp, cond), ops(ops) {};
 
            bool match(Instruction *I);
 
            static bool classof(const InstMapEntry* imap) {
                return imap->getKind() == BinaryOp;
            }
        private:
            Instruction::BinaryOps ops;
    };
 
    class CompOpMapEntry : public InstMapEntry {
        public:
            static constexpr InstMapEntry::InstMapKind CompOp =
             InstMapEntry::InstMapKind::CompOp;
            CompOpMapEntry(StringRef opcode, bool isInteger) :
                InstMapEntry(opcode, CompOp),
                isInteger(isInteger) {};
 
            CompOpMapEntry(StringRef opcode, bool isInteger,
                            MapCondition *cond) :
                InstMapEntry(opcode, CompOp, cond),
                isInteger(isInteger) {};
 
            static bool classof(const InstMapEntry* imap) {
                return imap->getKind() == CompOp;
            }
 
            bool match(Instruction *I);
        private:
            bool isInteger;
    };
 
    class MemoryOpMapEntry : public InstMapEntry {
        public:
            static constexpr InstMapEntry::InstMapKind MemOp =
                InstMapEntry::InstMapKind::MemOp;
            MemoryOpMapEntry(StringRef opcode, Instruction::MemoryOps kind) :
                InstMapEntry(opcode, MemOp),
                mem_kind(kind) {};
            MemoryOpMapEntry(StringRef opcode, Instruction::MemoryOps kind,
                                MapCondition *cond) :
                InstMapEntry(opcode, MemOp, cond),
                mem_kind(kind) {};
 
            static bool classof(const InstMapEntry* imap) {
                return imap->getKind() == MemOp;
            }
 
            bool match(Instruction *I);
        private:
            Instruction::MemoryOps mem_kind;
    };
 
    class CustomInstMapEntry : public InstMapEntry {
        public:
            static constexpr InstMapEntry::InstMapKind CustomOp =
                InstMapEntry::InstMapKind::CustomOp;
            CustomInstMapEntry(StringRef func_name, 
                                ModuleAnalysisManager &MAM) : 
                                InstMapEntry(func_name, CustomOp), MAM(MAM) {};
            CustomInstMapEntry(StringRef func_name, 
                                ModuleAnalysisManager &MAM,
                                MapCondition* map_cond) :
                InstMapEntry(func_name, CustomOp, map_cond), MAM(MAM) {};
 
            static bool classof(const InstMapEntry* imap) {
                return imap->getKind() == CustomOp;
            }
 
            bool match(Instruction *I);
 
        private:
            bool isCustomOpFunc(Function *F);
            ModuleAnalysisManager &MAM;
    };
 
    class OtherOpMapEntry : public InstMapEntry {
        public:
            static constexpr InstMapEntry::InstMapKind OtherOp =
                 InstMapEntry::InstMapKind::OtherOp;
            OtherOpMapEntry(StringRef opcode, Instruction::TermOps ops) :
                InstMapEntry(opcode, OtherOp), term_ops(ops), 
                cat(OptCategory::Terminator) {};
 
            OtherOpMapEntry(StringRef opcode, Instruction::CastOps ops) :
                InstMapEntry(opcode, OtherOp), cast_ops(ops), cat(OptCategory::Cast) {};
 
            OtherOpMapEntry(StringRef opcode, Instruction::OtherOps ops) :
                InstMapEntry(opcode, OtherOp), other_ops(ops),
                cat(OptCategory::Other) {};
 
            template <typename OpEnumTy>
            OtherOpMapEntry(StringRef opcode, OpEnumTy ops,
                                MapCondition* cond) :
                OtherOpMapEntry(opcode, ops) {
                    map_cond = cond;
                };
 
            bool match(Instruction *I);
 
            static bool classof(const InstMapEntry* imap) {
                return imap->getKind() == OtherOp;
            }
        private:
            enum class OptCategory {
                Terminator,
                Cast,
                Other,
            };
            OptCategory cat;
            Instruction::OtherOps other_ops;
            Instruction::TermOps term_ops;
            Instruction::CastOps cast_ops;
    };
 
    class InstMap {
        public:
            InstMap() {};
 
            InstMapEntry* find(StringRef opcode);
            InstMapEntry* find(Instruction *I);
 
            Error add_generic_inst(StringRef opcode);
 
            void add_custom_inst(StringRef opcode, ModuleAnalysisManager &MAM);
 
            Error add_map_entry(StringRef opcode, MapCondition* map_cond);
 
        private:
            using entry_ptr = std::shared_ptr<InstMapEntry>;
            using entry_iterator = SmallVector<entry_ptr>::iterator;
            using entry_generator = std::function<entry_ptr(MapCondition*)>;
 
            static StringMap<entry_generator> entry_gen;
 
            SmallVector<entry_ptr> entries;
            StringMap<entry_ptr> defaultEntries;
 
    };
 
} // namespace CGRAOmp
 
#endif //CGRAInstMap_H