File Manager

003 File Manager

Current Path: /usr/src/contrib/llvm-project/llvm/lib/Target/Hexagon/MCTargetDesc

usr / src / contrib / llvm-project / llvm / lib / Target / Hexagon / MCTargetDesc /

📁 ..
📄 HexagonAsmBackend.cpp(30.04 KB)
📄 HexagonBaseInfo.h(7.71 KB)
📄 HexagonELFObjectWriter.cpp(9.95 KB)
📄 HexagonFixupKinds.h(3.85 KB)
📄 HexagonInstPrinter.cpp(3.16 KB)
📄 HexagonInstPrinter.h(1.81 KB)
📄 HexagonMCAsmInfo.cpp(1.25 KB)
📄 HexagonMCAsmInfo.h(883 B)
📄 HexagonMCChecker.cpp(26.41 KB)
📄 HexagonMCChecker.h(4.32 KB)
📄 HexagonMCCodeEmitter.cpp(35.99 KB)
📄 HexagonMCCodeEmitter.h(3.26 KB)
📄 HexagonMCCompound.cpp(14.66 KB)
📄 HexagonMCDuplexInfo.cpp(36.66 KB)
📄 HexagonMCELFStreamer.cpp(6.03 KB)
📄 HexagonMCELFStreamer.h(2.03 KB)
📄 HexagonMCExpr.cpp(3.52 KB)
📄 HexagonMCExpr.h(1.57 KB)
📄 HexagonMCInstrInfo.cpp(36.94 KB)
📄 HexagonMCInstrInfo.h(13.99 KB)
📄 HexagonMCShuffler.cpp(7.31 KB)
📄 HexagonMCShuffler.h(2.36 KB)
📄 HexagonMCTargetDesc.cpp(20.61 KB)
📄 HexagonMCTargetDesc.h(4.04 KB)
📄 HexagonShuffler.cpp(22.33 KB)
📄 HexagonShuffler.h(7.73 KB)

Editing: HexagonMCChecker.h

//===- HexagonMCChecker.h - Instruction bundle checking ---------*- C++ -*-===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// This implements the checking of insns inside a bundle according to the
// packet constraint rules of the Hexagon ISA.
//
//===----------------------------------------------------------------------===//

#ifndef LLVM_LIB_TARGET_HEXAGON_MCTARGETDESC_HEXAGONMCCHECKER_H
#define LLVM_LIB_TARGET_HEXAGON_MCTARGETDESC_HEXAGONMCCHECKER_H

#include "MCTargetDesc/HexagonMCInstrInfo.h"
#include "MCTargetDesc/HexagonMCTargetDesc.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/Support/SMLoc.h"
#include <set>
#include <utility>

namespace llvm {

class MCContext;
class MCInst;
class MCInstrInfo;
class MCRegisterInfo;
class MCSubtargetInfo;

/// Check for a valid bundle.
class HexagonMCChecker {
  MCContext &Context;
  MCInst &MCB;
  const MCRegisterInfo &RI;
  MCInstrInfo const &MCII;
  MCSubtargetInfo const &STI;
  bool ReportErrors;

/// Set of definitions: register #, if predicated, if predicated true.
  using PredSense = std::pair<unsigned, bool>;
  static const PredSense Unconditional;
  using PredSet = std::multiset<PredSense>;
  using PredSetIterator = std::multiset<PredSense>::iterator;

using DefsIterator = DenseMap<unsigned, PredSet>::iterator;
  DenseMap<unsigned, PredSet> Defs;

/// Set of weak definitions whose clashes should be enforced selectively.
  using SoftDefsIterator = std::set<unsigned>::iterator;
  std::set<unsigned> SoftDefs;

/// Set of temporary definitions not committed to the register file.
  using TmpDefsIterator = std::set<unsigned>::iterator;
  std::set<unsigned> TmpDefs;

/// Set of new predicates used.
  using NewPredsIterator = std::set<unsigned>::iterator;
  std::set<unsigned> NewPreds;

/// Set of predicates defined late.
  using LatePredsIterator = std::multiset<unsigned>::iterator;
  std::multiset<unsigned> LatePreds;

/// Set of uses.
  using UsesIterator = std::set<unsigned>::iterator;
  std::set<unsigned> Uses;

/// Pre-defined set of read-only registers.
  using ReadOnlyIterator = std::set<unsigned>::iterator;
  std::set<unsigned> ReadOnly;

// Contains the vector-pair-registers with the even number
  // first ("v0:1", e.g.) used/def'd in this packet.
  std::set<unsigned> ReversePairs;

void init();
  void init(MCInst const &);
  void initReg(MCInst const &, unsigned, unsigned &PredReg, bool &isTrue);

bool registerUsed(unsigned Register);
  std::tuple<MCInst const *, unsigned, HexagonMCInstrInfo::PredicateInfo>
  registerProducer(unsigned Register,
                   HexagonMCInstrInfo::PredicateInfo Predicated);

// Checks performed.
  bool checkBranches();
  bool checkPredicates();
  bool checkNewValues();
  bool checkRegisters();
  bool checkRegistersReadOnly();
  void checkRegisterCurDefs();
  bool checkSolo();
  bool checkShuffle();
  bool checkSlots();
  bool checkAXOK();
  bool checkHWLoop();
  bool checkCOFMax1();
  bool checkLegalVecRegPair();

static void compoundRegisterMap(unsigned &);

bool isPredicateRegister(unsigned R) const {
    return (Hexagon::P0 == R || Hexagon::P1 == R || Hexagon::P2 == R ||
            Hexagon::P3 == R);
  }

bool isLoopRegister(unsigned R) const {
    return (Hexagon::SA0 == R || Hexagon::LC0 == R || Hexagon::SA1 == R ||
            Hexagon::LC1 == R);
  }

public:
  explicit HexagonMCChecker(MCContext &Context, MCInstrInfo const &MCII,
                            MCSubtargetInfo const &STI, MCInst &mcb,
                            const MCRegisterInfo &ri, bool ReportErrors = true);
  explicit HexagonMCChecker(HexagonMCChecker const &Check,
                            MCSubtargetInfo const &STI, bool CopyReportErrors);

bool check(bool FullCheck = true);
  void reportErrorRegisters(unsigned Register);
  void reportErrorNewValue(unsigned Register);
  void reportError(SMLoc Loc, Twine const &Msg);
  void reportNote(SMLoc Loc, Twine const &Msg);
  void reportError(Twine const &Msg);
  void reportWarning(Twine const &Msg);
  void reportBranchErrors();
};

} // end namespace llvm

#endif // LLVM_LIB_TARGET_HEXAGON_MCTARGETDESC_HEXAGONMCCHECKER_H

003 File Manager

Editing: HexagonMCChecker.h

Upload File

Create Folder