Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===- InstructionCost.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

//

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

/// \file

/// This file defines an InstructionCost class that is used when calculating

/// the cost of an instruction, or a group of instructions. In addition to a

/// numeric value representing the cost the class also contains a state that

/// can be used to encode particular properties, such as a cost being invalid.

/// Operations on InstructionCost implement saturation arithmetic, so that

/// accumulating costs on large cost-values don't overflow.

///

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

#ifndef LLVM_SUPPORT_INSTRUCTIONCOST_H

#define LLVM_SUPPORT_INSTRUCTIONCOST_H

#include "llvm/Support/MathExtras.h"

#include <limits>

#include <optional>

namespace llvm {

class raw_ostream;

class InstructionCost {

public:

  using CostType = int64_t;

  /// CostState describes the state of a cost.

  enum CostState {

    Valid,  /// < The cost value represents a valid cost, even when the

            /// cost-value is large.

    Invalid /// < Invalid indicates there is no way to represent the cost as a

            /// numeric value. This state exists to represent a possible issue,

            /// e.g. if the cost-model knows the operation cannot be expanded

            /// into a valid code-sequence by the code-generator.  While some

            /// passes may assert that the calculated cost must be valid, it is

            /// up to individual passes how to interpret an Invalid cost. For

            /// example, a transformation pass could choose not to perform a

            /// transformation if the resulting cost would end up Invalid.

            /// Because some passes may assert a cost is Valid, it is not

            /// recommended to use Invalid costs to model 'Unknown'.

            /// Note that Invalid is semantically different from a (very) high,

            /// but valid cost, which intentionally indicates no issue, but

            /// rather a strong preference not to select a certain operation.

  };

private:

  CostType Value = 0;

  CostState State = Valid;

  void propagateState(const InstructionCost &RHS) {

    if (RHS.State == Invalid)

      State = Invalid;

  }

  static CostType getMaxValue() { return std::numeric_limits<CostType>::max(); }

  static CostType getMinValue() { return std::numeric_limits<CostType>::min(); }

public:

  // A default constructed InstructionCost is a valid zero cost

  InstructionCost() = default;

  InstructionCost(CostState) = delete;

  InstructionCost(CostType Val) : Value(Val), State(Valid) {}

  static InstructionCost getMax() { return getMaxValue(); }

  static InstructionCost getMin() { return getMinValue(); }

  static InstructionCost getInvalid(CostType Val = 0) {

    InstructionCost Tmp(Val);

    Tmp.setInvalid();

    return Tmp;

  }

  bool isValid() const { return State == Valid; }

  void setValid() { State = Valid; }

  void setInvalid() { State = Invalid; }

  CostState getState() const { return State; }

  /// This function is intended to be used as sparingly as possible, since the

  /// class provides the full range of operator support required for arithmetic

  /// and comparisons.

  std::optional<CostType> getValue() const {

    if (isValid())

      return Value;

    return std::nullopt;

  }

  /// For all of the arithmetic operators provided here any invalid state is

  /// perpetuated and cannot be removed. Once a cost becomes invalid it stays

  /// invalid, and it also inherits any invalid state from the RHS.

  /// Arithmetic work on the actual values is implemented with saturation,

  /// to avoid overflow when using more extreme cost values.

  InstructionCost &operator+=(const InstructionCost &RHS) {

    propagateState(RHS);

    // Saturating addition.

    InstructionCost::CostType Result;

    if (AddOverflow(Value, RHS.Value, Result))

      Result = RHS.Value > 0 ? getMaxValue() : getMinValue();

    Value = Result;

    return *this;

  }

  InstructionCost &operator+=(const CostType RHS) {

    InstructionCost RHS2(RHS);

    *this += RHS2;

    return *this;

  }

  InstructionCost &operator-=(const InstructionCost &RHS) {

    propagateState(RHS);

    // Saturating subtract.

    InstructionCost::CostType Result;

    if (SubOverflow(Value, RHS.Value, Result))

      Result = RHS.Value > 0 ? getMinValue() : getMaxValue();

    Value = Result;

    return *this;

  }

  InstructionCost &operator-=(const CostType RHS) {

    InstructionCost RHS2(RHS);

    *this -= RHS2;

    return *this;

  }

  InstructionCost &operator*=(const InstructionCost &RHS) {

    propagateState(RHS);

    // Saturating multiply.

    InstructionCost::CostType Result;

    if (MulOverflow(Value, RHS.Value, Result)) {

      if ((Value > 0 && RHS.Value > 0) || (Value < 0 && RHS.Value < 0))

        Result = getMaxValue();

      else

        Result = getMinValue();

    }

    Value = Result;

    return *this;

  }

  InstructionCost &operator*=(const CostType RHS) {

    InstructionCost RHS2(RHS);

    *this *= RHS2;

    return *this;

  }

  InstructionCost &operator/=(const InstructionCost &RHS) {

    propagateState(RHS);

    Value /= RHS.Value;

    return *this;

  }

  InstructionCost &operator/=(const CostType RHS) {

    InstructionCost RHS2(RHS);

    *this /= RHS2;

    return *this;

  }

  InstructionCost &operator++() {

    *this += 1;

    return *this;

  }

  InstructionCost operator++(int) {

    InstructionCost Copy = *this;

    ++*this;

    return Copy;

  }

  InstructionCost &operator--() {

    *this -= 1;

    return *this;

  }

  InstructionCost operator--(int) {

    InstructionCost Copy = *this;

    --*this;

    return Copy;

  }

  /// For the comparison operators we have chosen to use lexicographical

  /// ordering where valid costs are always considered to be less than invalid

  /// costs. This avoids having to add asserts to the comparison operators that

  /// the states are valid and users can test for validity of the cost

  /// explicitly.

  bool operator<(const InstructionCost &RHS) const {

    if (State != RHS.State)

      return State < RHS.State;

    return Value < RHS.Value;

  }

  // Implement in terms of operator< to ensure that the two comparisons stay in

  // sync

  bool operator==(const InstructionCost &RHS) const {

    return !(*this < RHS) && !(RHS < *this);

  }

  bool operator!=(const InstructionCost &RHS) const { return !(*this == RHS); }

  bool operator==(const CostType RHS) const {

    InstructionCost RHS2(RHS);

    return *this == RHS2;

  }

  bool operator!=(const CostType RHS) const { return !(*this == RHS); }

  bool operator>(const InstructionCost &RHS) const { return RHS < *this; }

  bool operator<=(const InstructionCost &RHS) const { return !(RHS < *this); }

  bool operator>=(const InstructionCost &RHS) const { return !(*this < RHS); }

  bool operator<(const CostType RHS) const {

    InstructionCost RHS2(RHS);

    return *this < RHS2;

  }

  bool operator>(const CostType RHS) const {

    InstructionCost RHS2(RHS);

    return *this > RHS2;

  }

  bool operator<=(const CostType RHS) const {

    InstructionCost RHS2(RHS);

    return *this <= RHS2;

  }

  bool operator>=(const CostType RHS) const {

    InstructionCost RHS2(RHS);

    return *this >= RHS2;

  }

  void print(raw_ostream &OS) const;

  template <class Function>

  auto map(const Function &F) const -> InstructionCost {

    if (isValid())

      return F(Value);

    return getInvalid();

  }

};

inline InstructionCost operator+(const InstructionCost &LHS,

                                 const InstructionCost &RHS) {

  InstructionCost LHS2(LHS);

  LHS2 += RHS;

  return LHS2;

}

inline InstructionCost operator-(const InstructionCost &LHS,

                                 const InstructionCost &RHS) {

  InstructionCost LHS2(LHS);

  LHS2 -= RHS;

  return LHS2;

}

inline InstructionCost operator*(const InstructionCost &LHS,

                                 const InstructionCost &RHS) {

  InstructionCost LHS2(LHS);

  LHS2 *= RHS;

  return LHS2;

}

inline InstructionCost operator/(const InstructionCost &LHS,

                                 const InstructionCost &RHS) {

  InstructionCost LHS2(LHS);

  LHS2 /= RHS;

  return LHS2;

}

inline raw_ostream &operator<<(raw_ostream &OS, const InstructionCost &V) {

  V.print(OS);

  return OS;

}

} // namespace llvm

#endif