Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===- llvm/CodeGen/MachineInstrBundleIterator.h ----------------*- 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

//

//===----------------------------------------------------------------------===//

//

// Defines an iterator class that bundles MachineInstr.

//

//===----------------------------------------------------------------------===//

#ifndef LLVM_CODEGEN_MACHINEINSTRBUNDLEITERATOR_H

#define LLVM_CODEGEN_MACHINEINSTRBUNDLEITERATOR_H

#include "llvm/ADT/ilist.h"

#include "llvm/ADT/simple_ilist.h"

#include <cassert>

#include <iterator>

#include <type_traits>

namespace llvm {

template <class T, bool IsReverse> struct MachineInstrBundleIteratorTraits;

template <class T> struct MachineInstrBundleIteratorTraits<T, false> {

  using list_type = simple_ilist<T, ilist_sentinel_tracking<true>>;

  using instr_iterator = typename list_type::iterator;

  using nonconst_instr_iterator = typename list_type::iterator;

  using const_instr_iterator = typename list_type::const_iterator;

};

template <class T> struct MachineInstrBundleIteratorTraits<T, true> {

  using list_type = simple_ilist<T, ilist_sentinel_tracking<true>>;

  using instr_iterator = typename list_type::reverse_iterator;

  using nonconst_instr_iterator = typename list_type::reverse_iterator;

  using const_instr_iterator = typename list_type::const_reverse_iterator;

};

template <class T> struct MachineInstrBundleIteratorTraits<const T, false> {

  using list_type = simple_ilist<T, ilist_sentinel_tracking<true>>;

  using instr_iterator = typename list_type::const_iterator;

  using nonconst_instr_iterator = typename list_type::iterator;

  using const_instr_iterator = typename list_type::const_iterator;

};

template <class T> struct MachineInstrBundleIteratorTraits<const T, true> {

  using list_type = simple_ilist<T, ilist_sentinel_tracking<true>>;

  using instr_iterator = typename list_type::const_reverse_iterator;

  using nonconst_instr_iterator = typename list_type::reverse_iterator;

  using const_instr_iterator = typename list_type::const_reverse_iterator;

};

template <bool IsReverse> struct MachineInstrBundleIteratorHelper;

template <> struct MachineInstrBundleIteratorHelper<false> {

  /// Get the beginning of the current bundle.

  template <class Iterator> static Iterator getBundleBegin(Iterator I) {

    if (!I.isEnd())

      while (I->isBundledWithPred())

        --I;

    return I;

  }

  /// Get the final node of the current bundle.

  template <class Iterator> static Iterator getBundleFinal(Iterator I) {

    if (!I.isEnd())

      while (I->isBundledWithSucc())

        ++I;

    return I;

  }

  /// Increment forward ilist iterator.

  template <class Iterator> static void increment(Iterator &I) {

    I = std::next(getBundleFinal(I));

  }

  /// Decrement forward ilist iterator.

  template <class Iterator> static void decrement(Iterator &I) {

    I = getBundleBegin(std::prev(I));

  }

};

template <> struct MachineInstrBundleIteratorHelper<true> {

  /// Get the beginning of the current bundle.

  template <class Iterator> static Iterator getBundleBegin(Iterator I) {

    return MachineInstrBundleIteratorHelper<false>::getBundleBegin(

               I.getReverse())

        .getReverse();

  }

  /// Get the final node of the current bundle.

  template <class Iterator> static Iterator getBundleFinal(Iterator I) {

    return MachineInstrBundleIteratorHelper<false>::getBundleFinal(

               I.getReverse())

        .getReverse();

  }

  /// Increment reverse ilist iterator.

  template <class Iterator> static void increment(Iterator &I) {

    I = getBundleBegin(std::next(I));

  }

  /// Decrement reverse ilist iterator.

  template <class Iterator> static void decrement(Iterator &I) {

    I = std::prev(getBundleFinal(I));

  }

};

/// MachineBasicBlock iterator that automatically skips over MIs that are

/// inside bundles (i.e. walk top level MIs only).

template <typename Ty, bool IsReverse = false>

class MachineInstrBundleIterator : MachineInstrBundleIteratorHelper<IsReverse> {

  using Traits = MachineInstrBundleIteratorTraits<Ty, IsReverse>;

  using instr_iterator = typename Traits::instr_iterator;

  instr_iterator MII;

public:

  using value_type = typename instr_iterator::value_type;

  using difference_type = typename instr_iterator::difference_type;

  using pointer = typename instr_iterator::pointer;

  using reference = typename instr_iterator::reference;

  using const_pointer = typename instr_iterator::const_pointer;

  using const_reference = typename instr_iterator::const_reference;

  using iterator_category = std::bidirectional_iterator_tag;

private:

  using nonconst_instr_iterator = typename Traits::nonconst_instr_iterator;

  using const_instr_iterator = typename Traits::const_instr_iterator;

  using nonconst_iterator =

      MachineInstrBundleIterator<typename nonconst_instr_iterator::value_type,

                                 IsReverse>;

  using reverse_iterator = MachineInstrBundleIterator<Ty, !IsReverse>;

public:

  MachineInstrBundleIterator(instr_iterator MI) : MII(MI) {

    assert((!MI.getNodePtr() || MI.isEnd() || !MI->isBundledWithPred()) &&

           "It's not legal to initialize MachineInstrBundleIterator with a "

           "bundled MI");

  }

  MachineInstrBundleIterator(reference MI) : MII(MI) {

    assert(!MI.isBundledWithPred() && "It's not legal to initialize "

                                      "MachineInstrBundleIterator with a "

                                      "bundled MI");

  }

  MachineInstrBundleIterator(pointer MI) : MII(MI) {

    // FIXME: This conversion should be explicit.

    assert((!MI || !MI->isBundledWithPred()) && "It's not legal to initialize "

                                                "MachineInstrBundleIterator "

                                                "with a bundled MI");

  }

  // Template allows conversion from const to nonconst.

  template <class OtherTy>

  MachineInstrBundleIterator(

      const MachineInstrBundleIterator<OtherTy, IsReverse> &I,

      std::enable_if_t<std::is_convertible<OtherTy *, Ty *>::value, void *> =

          nullptr)

      : MII(I.getInstrIterator()) {}

  MachineInstrBundleIterator() : MII(nullptr) {}

  /// Explicit conversion between forward/reverse iterators.

  ///

  /// Translate between forward and reverse iterators without changing range

  /// boundaries.  The resulting iterator will dereference (and have a handle)

  /// to the previous node, which is somewhat unexpected; but converting the

  /// two endpoints in a range will give the same range in reverse.

  ///

  /// This matches std::reverse_iterator conversions.

  explicit MachineInstrBundleIterator(

      const MachineInstrBundleIterator<Ty, !IsReverse> &I)

      : MachineInstrBundleIterator(++I.getReverse()) {}

  /// Get the bundle iterator for the given instruction's bundle.

  static MachineInstrBundleIterator getAtBundleBegin(instr_iterator MI) {

    return MachineInstrBundleIteratorHelper<IsReverse>::getBundleBegin(MI);

  }

  reference operator*() const { return *MII; }

  pointer operator->() const { return &operator*(); }

  /// Check for null.

  bool isValid() const { return MII.getNodePtr(); }

  friend bool operator==(const MachineInstrBundleIterator &L,

                         const MachineInstrBundleIterator &R) {

    return L.MII == R.MII;

  }

  friend bool operator==(const MachineInstrBundleIterator &L,

                         const const_instr_iterator &R) {

    return L.MII == R; // Avoid assertion about validity of R.

  }

  friend bool operator==(const const_instr_iterator &L,

                         const MachineInstrBundleIterator &R) {

    return L == R.MII; // Avoid assertion about validity of L.

  }

  friend bool operator==(const MachineInstrBundleIterator &L,

                         const nonconst_instr_iterator &R) {

    return L.MII == R; // Avoid assertion about validity of R.

  }

  friend bool operator==(const nonconst_instr_iterator &L,

                         const MachineInstrBundleIterator &R) {

    return L == R.MII; // Avoid assertion about validity of L.

  }

  friend bool operator==(const MachineInstrBundleIterator &L, const_pointer R) {

    return L == const_instr_iterator(R); // Avoid assertion about validity of R.

  }

  friend bool operator==(const_pointer L, const MachineInstrBundleIterator &R) {

    return const_instr_iterator(L) == R; // Avoid assertion about validity of L.

  }

  friend bool operator==(const MachineInstrBundleIterator &L,

                         const_reference R) {

    return L == &R; // Avoid assertion about validity of R.

  }

  friend bool operator==(const_reference L,

                         const MachineInstrBundleIterator &R) {

    return &L == R; // Avoid assertion about validity of L.

  }

  friend bool operator!=(const MachineInstrBundleIterator &L,

                         const MachineInstrBundleIterator &R) {

    return !(L == R);

  }

  friend bool operator!=(const MachineInstrBundleIterator &L,

                         const const_instr_iterator &R) {

    return !(L == R);

  }

  friend bool operator!=(const const_instr_iterator &L,

                         const MachineInstrBundleIterator &R) {

    return !(L == R);

  }

  friend bool operator!=(const MachineInstrBundleIterator &L,

                         const nonconst_instr_iterator &R) {

    return !(L == R);

  }

  friend bool operator!=(const nonconst_instr_iterator &L,

                         const MachineInstrBundleIterator &R) {

    return !(L == R);

  }

  friend bool operator!=(const MachineInstrBundleIterator &L, const_pointer R) {

    return !(L == R);

  }

  friend bool operator!=(const_pointer L, const MachineInstrBundleIterator &R) {

    return !(L == R);

  }

  friend bool operator!=(const MachineInstrBundleIterator &L,

                         const_reference R) {

    return !(L == R);

  }

  friend bool operator!=(const_reference L,

                         const MachineInstrBundleIterator &R) {

    return !(L == R);

  }

  // Increment and decrement operators...

  MachineInstrBundleIterator &operator--() {

    this->decrement(MII);

    return *this;

  }

  MachineInstrBundleIterator &operator++() {

    this->increment(MII);

    return *this;

  }

  MachineInstrBundleIterator operator--(int) {

    MachineInstrBundleIterator Temp = *this;

    --*this;

    return Temp;

  }

  MachineInstrBundleIterator operator++(int) {

    MachineInstrBundleIterator Temp = *this;

    ++*this;

    return Temp;

  }

  instr_iterator getInstrIterator() const { return MII; }

  nonconst_iterator getNonConstIterator() const { return MII.getNonConst(); }

  /// Get a reverse iterator to the same node.

  ///

  /// Gives a reverse iterator that will dereference (and have a handle) to the

  /// same node.  Converting the endpoint iterators in a range will give a

  /// different range; for range operations, use the explicit conversions.

  reverse_iterator getReverse() const { return MII.getReverse(); }

};

} // end namespace llvm

#endif // LLVM_CODEGEN_MACHINEINSTRBUNDLEITERATOR_H