Home | History | Annotate | Download | only in llvm-mca 
      1 //===-------------------------- CodeRegion.h -------------------*- C++ -* -===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 /// \file
     10 ///
     11 /// This file implements class CodeRegion and CodeRegions.
     12 ///
     13 /// A CodeRegion describes a region of assembly code guarded by special LLVM-MCA
     14 /// comment directives.
     15 ///
     16 ///   # LLVM-MCA-BEGIN foo
     17 ///     ...  ## asm
     18 ///   # LLVM-MCA-END
     19 ///
     20 /// A comment starting with substring LLVM-MCA-BEGIN marks the beginning of a
     21 /// new region of code.
     22 /// A comment starting with substring LLVM-MCA-END marks the end of the
     23 /// last-seen region of code.
     24 ///
     25 /// Code regions are not allowed to overlap. Each region can have a optional
     26 /// description; internally, regions are described by a range of source
     27 /// locations (SMLoc objects).
     28 ///
     29 /// An instruction (a MCInst) is added to a region R only if its location is in
     30 /// range [R.RangeStart, R.RangeEnd].
     31 //
     32 //===----------------------------------------------------------------------===//
     33 
     34 #ifndef LLVM_TOOLS_LLVM_MCA_CODEREGION_H
     35 #define LLVM_TOOLS_LLVM_MCA_CODEREGION_H
     36 
     37 #include "llvm/ADT/StringRef.h"
     38 #include "llvm/MC/MCInst.h"
     39 #include "llvm/Support/SMLoc.h"
     40 #include "llvm/Support/SourceMgr.h"
     41 #include <vector>
     42 
     43 namespace mca {
     44 
     45 /// A region of assembly code.
     46 ///
     47 /// It identifies a sequence of machine instructions.
     48 class CodeRegion {
     49   // An optional descriptor for this region.
     50   llvm::StringRef Description;
     51   // Instructions that form this region.
     52   std::vector<std::unique_ptr<const llvm::MCInst>> Instructions;
     53   // Source location range.
     54   llvm::SMLoc RangeStart;
     55   llvm::SMLoc RangeEnd;
     56 
     57   CodeRegion(const CodeRegion &) = delete;
     58   CodeRegion &operator=(const CodeRegion &) = delete;
     59 
     60 public:
     61   CodeRegion(llvm::StringRef Desc, llvm::SMLoc Start)
     62       : Description(Desc), RangeStart(Start), RangeEnd() {}
     63 
     64   void addInstruction(std::unique_ptr<const llvm::MCInst> Instruction) {
     65     Instructions.emplace_back(std::move(Instruction));
     66   }
     67 
     68   llvm::SMLoc startLoc() const { return RangeStart; }
     69   llvm::SMLoc endLoc() const { return RangeEnd; }
     70 
     71   void setEndLocation(llvm::SMLoc End) { RangeEnd = End; }
     72   bool empty() const { return Instructions.empty(); }
     73   bool isLocInRange(llvm::SMLoc Loc) const;
     74 
     75   const std::vector<std::unique_ptr<const llvm::MCInst>> &
     76   getInstructions() const {
     77     return Instructions;
     78   }
     79 
     80   llvm::StringRef getDescription() const { return Description; }
     81 };
     82 
     83 class CodeRegions {
     84   // A source manager. Used by the tool to generate meaningful warnings.
     85   llvm::SourceMgr &SM;
     86 
     87   std::vector<std::unique_ptr<CodeRegion>> Regions;
     88 
     89   // Construct a new region of code guarded by LLVM-MCA comments.
     90   void addRegion(llvm::StringRef Description, llvm::SMLoc Loc) {
     91     Regions.emplace_back(llvm::make_unique<CodeRegion>(Description, Loc));
     92   }
     93 
     94   CodeRegions(const CodeRegions &) = delete;
     95   CodeRegions &operator=(const CodeRegions &) = delete;
     96 
     97 public:
     98   typedef std::vector<std::unique_ptr<CodeRegion>>::iterator iterator;
     99   typedef std::vector<std::unique_ptr<CodeRegion>>::const_iterator
    100       const_iterator;
    101 
    102   iterator begin() { return Regions.begin(); }
    103   iterator end() { return Regions.end(); }
    104   const_iterator begin() const { return Regions.cbegin(); }
    105   const_iterator end() const { return Regions.cend(); }
    106 
    107   void beginRegion(llvm::StringRef Description, llvm::SMLoc Loc);
    108   void endRegion(llvm::SMLoc Loc);
    109   void addInstruction(std::unique_ptr<const llvm::MCInst> Instruction);
    110 
    111   CodeRegions(llvm::SourceMgr &S) : SM(S) {
    112     // Create a default region for the input code sequence.
    113     addRegion("Default", llvm::SMLoc());
    114   }
    115 
    116   const std::vector<std::unique_ptr<const llvm::MCInst>> &
    117   getInstructionSequence(unsigned Idx) const {
    118     return Regions[Idx]->getInstructions();
    119   }
    120 
    121   bool empty() const {
    122     return std::all_of(Regions.begin(), Regions.end(),
    123                        [](const std::unique_ptr<CodeRegion> &Region) {
    124                          return Region->empty();
    125                        });
    126   }
    127 };
    128 
    129 } // namespace mca
    130 
    131 #endif
    132