EIC code displayed by LXR master/​include/​polly/​Support/​GICHelper.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-05-10 08:48:20

 //===- Support/GICHelper.h -- Helper functions for ISL --------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Helper functions for isl objects.
 //
 //===----------------------------------------------------------------------===//
 //
 #ifndef POLLY_SUPPORT_GIC_HELPER_H
 #define POLLY_SUPPORT_GIC_HELPER_H
 
 #include "llvm/ADT/APInt.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/Support/raw_ostream.h"
 #include "isl/ctx.h"
 #include "isl/isl-noexceptions.h"
 #include "isl/options.h"
 
 namespace polly {
 
 /// Translate an llvm::APInt to an isl_val.
 ///
 /// Translate the bitsequence without sign information as provided by APInt into
 /// a signed isl_val type. Depending on the value of @p IsSigned @p Int is
 /// interpreted as unsigned value or as signed value in two's complement
 /// representation.
 ///
 /// Input IsSigned                 Output
 ///
 ///     0        0           ->    0
 ///     1        0           ->    1
 ///    00        0           ->    0
 ///    01        0           ->    1
 ///    10        0           ->    2
 ///    11        0           ->    3
 ///
 ///     0        1           ->    0
 ///     1        1           ->   -1
 ///    00        1           ->    0
 ///    01        1           ->    1
 ///    10        1           ->   -2
 ///    11        1           ->   -1
 ///
 /// @param Ctx      The isl_ctx to create the isl_val in.
 /// @param Int      The integer value to translate.
 /// @param IsSigned If the APInt should be interpreted as signed or unsigned
 ///                 value.
 ///
 /// @return The isl_val corresponding to @p Int.
 __isl_give isl_val *isl_valFromAPInt(isl_ctx *Ctx, const llvm::APInt Int,
                                      bool IsSigned);
 
 /// Translate an llvm::APInt to an isl::val.
 ///
 /// Translate the bitsequence without sign information as provided by APInt into
 /// a signed isl::val type. Depending on the value of @p IsSigned @p Int is
 /// interpreted as unsigned value or as signed value in two's complement
 /// representation.
 ///
 /// Input IsSigned                 Output
 ///
 ///     0        0           ->    0
 ///     1        0           ->    1
 ///    00        0           ->    0
 ///    01        0           ->    1
 ///    10        0           ->    2
 ///    11        0           ->    3
 ///
 ///     0        1           ->    0
 ///     1        1           ->   -1
 ///    00        1           ->    0
 ///    01        1           ->    1
 ///    10        1           ->   -2
 ///    11        1           ->   -1
 ///
 /// @param Ctx      The isl_ctx to create the isl::val in.
 /// @param Int      The integer value to translate.
 /// @param IsSigned If the APInt should be interpreted as signed or unsigned
 ///                 value.
 ///
 /// @return The isl::val corresponding to @p Int.
 inline isl::val valFromAPInt(isl_ctx *Ctx, const llvm::APInt Int,
                              bool IsSigned) {
   return isl::manage(isl_valFromAPInt(Ctx, Int, IsSigned));
 }
 
 /// Translate isl_val to llvm::APInt.
 ///
 /// This function can only be called on isl_val values which are integers.
 /// Calling this function with a non-integral rational, NaN or infinity value
 /// is not allowed.
 ///
 /// As the input isl_val may be negative, the APInt that this function returns
 /// must always be interpreted as signed two's complement value. The bitwidth of
 /// the generated APInt is always the minimal bitwidth necessary to model the
 /// provided integer when interpreting the bit pattern as signed value.
 ///
 /// Some example conversions are:
 ///
 ///   Input      Bits    Signed  Bitwidth
 ///       0 ->      0         0         1
 ///      -1 ->      1        -1         1
 ///       1 ->     01         1         2
 ///      -2 ->     10        -2         2
 ///       2 ->    010         2         3
 ///      -3 ->    101        -3         3
 ///       3 ->    011         3         3
 ///      -4 ->    100        -4         3
 ///       4 ->   0100         4         4
 ///
 /// @param Val The isl val to translate.
 ///
 /// @return The APInt value corresponding to @p Val.
 llvm::APInt APIntFromVal(__isl_take isl_val *Val);
 
 /// Translate isl::val to llvm::APInt.
 ///
 /// This function can only be called on isl::val values which are integers.
 /// Calling this function with a non-integral rational, NaN or infinity value
 /// is not allowed.
 ///
 /// As the input isl::val may be negative, the APInt that this function returns
 /// must always be interpreted as signed two's complement value. The bitwidth of
 /// the generated APInt is always the minimal bitwidth necessary to model the
 /// provided integer when interpreting the bit pattern as signed value.
 ///
 /// Some example conversions are:
 ///
 ///   Input      Bits    Signed  Bitwidth
 ///       0 ->      0         0         1
 ///      -1 ->      1        -1         1
 ///       1 ->     01         1         2
 ///      -2 ->     10        -2         2
 ///       2 ->    010         2         3
 ///      -3 ->    101        -3         3
 ///       3 ->    011         3         3
 ///      -4 ->    100        -4         3
 ///       4 ->   0100         4         4
 ///
 /// @param Val The isl val to translate.
 ///
 /// @return The APInt value corresponding to @p Val.
 inline llvm::APInt APIntFromVal(isl::val V) {
   return APIntFromVal(V.release());
 }
 
 /// Get c++ string from Isl objects.
 //@{
 #define ISL_CPP_OBJECT_TO_STRING(name)                                         \
   inline std::string stringFromIslObj(const name &Obj,                         \
                                       std::string DefaultValue = "") {         \
     return stringFromIslObj(Obj.get(), DefaultValue);                          \
   }
 
 #define ISL_OBJECT_TO_STRING(name)                                             \
   std::string stringFromIslObj(__isl_keep isl_##name *Obj,                     \
                                std::string DefaultValue = "");                 \
   ISL_CPP_OBJECT_TO_STRING(isl::name)
 
 ISL_OBJECT_TO_STRING(aff)
 ISL_OBJECT_TO_STRING(ast_expr)
 ISL_OBJECT_TO_STRING(ast_node)
 ISL_OBJECT_TO_STRING(basic_map)
 ISL_OBJECT_TO_STRING(basic_set)
 ISL_OBJECT_TO_STRING(map)
 ISL_OBJECT_TO_STRING(set)
 ISL_OBJECT_TO_STRING(id)
 ISL_OBJECT_TO_STRING(multi_aff)
 ISL_OBJECT_TO_STRING(multi_pw_aff)
 ISL_OBJECT_TO_STRING(multi_union_pw_aff)
 ISL_OBJECT_TO_STRING(point)
 ISL_OBJECT_TO_STRING(pw_aff)
 ISL_OBJECT_TO_STRING(pw_multi_aff)
 ISL_OBJECT_TO_STRING(schedule)
 ISL_OBJECT_TO_STRING(schedule_node)
 ISL_OBJECT_TO_STRING(space)
 ISL_OBJECT_TO_STRING(union_access_info)
 ISL_OBJECT_TO_STRING(union_flow)
 ISL_OBJECT_TO_STRING(union_set)
 ISL_OBJECT_TO_STRING(union_map)
 ISL_OBJECT_TO_STRING(union_pw_aff)
 ISL_OBJECT_TO_STRING(union_pw_multi_aff)
 //@}
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 /// C++ wrapper for isl_*_dump() functions.
 //@{
 
 #define ISL_DUMP_OBJECT(name)                                                  \
   void dumpIslObj(const isl::name &Obj);                                       \
   void dumpIslObj(isl_##name *Obj);
 
 ISL_DUMP_OBJECT(aff)
 ISL_DUMP_OBJECT(aff_list)
 ISL_DUMP_OBJECT(ast_expr)
 ISL_DUMP_OBJECT(ast_node)
 ISL_DUMP_OBJECT(ast_node_list)
 ISL_DUMP_OBJECT(basic_map)
 ISL_DUMP_OBJECT(basic_map_list)
 ISL_DUMP_OBJECT(basic_set)
 ISL_DUMP_OBJECT(basic_set_list)
 ISL_DUMP_OBJECT(constraint)
 ISL_DUMP_OBJECT(id)
 ISL_DUMP_OBJECT(id_list)
 ISL_DUMP_OBJECT(id_to_ast_expr)
 ISL_DUMP_OBJECT(local_space)
 ISL_DUMP_OBJECT(map)
 ISL_DUMP_OBJECT(map_list)
 ISL_DUMP_OBJECT(multi_aff)
 ISL_DUMP_OBJECT(multi_pw_aff)
 ISL_DUMP_OBJECT(multi_union_pw_aff)
 ISL_DUMP_OBJECT(multi_val)
 ISL_DUMP_OBJECT(point)
 ISL_DUMP_OBJECT(pw_aff)
 ISL_DUMP_OBJECT(pw_aff_list)
 ISL_DUMP_OBJECT(pw_multi_aff)
 ISL_DUMP_OBJECT(schedule)
 ISL_DUMP_OBJECT(schedule_constraints)
 ISL_DUMP_OBJECT(schedule_node)
 ISL_DUMP_OBJECT(set)
 ISL_DUMP_OBJECT(set_list)
 ISL_DUMP_OBJECT(space)
 ISL_DUMP_OBJECT(union_map)
 ISL_DUMP_OBJECT(union_pw_aff)
 ISL_DUMP_OBJECT(union_pw_aff_list)
 ISL_DUMP_OBJECT(union_pw_multi_aff)
 ISL_DUMP_OBJECT(union_set)
 ISL_DUMP_OBJECT(union_set_list)
 ISL_DUMP_OBJECT(val)
 ISL_DUMP_OBJECT(val_list)
 //@}
 
 /// Emit the equivaltent of the isl_*_dump output into a raw_ostream.
 /// @{
 void dumpIslObj(const isl::schedule_node &Node, llvm::raw_ostream &OS);
 void dumpIslObj(__isl_keep isl_schedule_node *node, llvm::raw_ostream &OS);
 /// @}
 #endif
 
 inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                                      __isl_keep isl_union_map *Map) {
   OS << polly::stringFromIslObj(Map, "null");
   return OS;
 }
 
 inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                                      __isl_keep isl_map *Map) {
   OS << polly::stringFromIslObj(Map, "null");
   return OS;
 }
 
 inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                                      __isl_keep isl_set *Set) {
   OS << polly::stringFromIslObj(Set, "null");
   return OS;
 }
 
 inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                                      __isl_keep isl_pw_aff *Map) {
   OS << polly::stringFromIslObj(Map, "null");
   return OS;
 }
 
 inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                                      __isl_keep isl_pw_multi_aff *PMA) {
   OS << polly::stringFromIslObj(PMA, "null");
   return OS;
 }
 
 inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                                      __isl_keep isl_multi_aff *MA) {
   OS << polly::stringFromIslObj(MA, "null");
   return OS;
 }
 
 inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                                      __isl_keep isl_union_pw_multi_aff *UPMA) {
   OS << polly::stringFromIslObj(UPMA, "null");
   return OS;
 }
 
 inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                                      __isl_keep isl_schedule *Schedule) {
   OS << polly::stringFromIslObj(Schedule, "null");
   return OS;
 }
 
 inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                                      __isl_keep isl_space *Space) {
   OS << polly::stringFromIslObj(Space, "null");
   return OS;
 }
 
 /// Combine Prefix, Val (or Number) and Suffix to an isl-compatible name.
 ///
 /// In case @p UseInstructionNames is set, this function returns:
 ///
 /// @p Prefix + "_" + @p Val->getName() + @p Suffix
 ///
 /// otherwise
 ///
 /// @p Prefix + to_string(Number) + @p Suffix
 ///
 /// We ignore the value names by default, as they may change between release
 /// and debug mode and can consequently not be used when aiming for reproducible
 /// builds. However, for debugging named statements are often helpful, hence
 /// we allow their optional use.
 std::string getIslCompatibleName(const std::string &Prefix,
                                  const llvm::Value *Val, long Number,
                                  const std::string &Suffix,
                                  bool UseInstructionNames);
 
 /// Combine Prefix, Name (or Number) and Suffix to an isl-compatible name.
 ///
 /// In case @p UseInstructionNames is set, this function returns:
 ///
 /// @p Prefix + "_" + Name + @p Suffix
 ///
 /// otherwise
 ///
 /// @p Prefix + to_string(Number) + @p Suffix
 ///
 /// We ignore @p Name by default, as they may change between release
 /// and debug mode and can consequently not be used when aiming for reproducible
 /// builds. However, for debugging named statements are often helpful, hence
 /// we allow their optional use.
 std::string getIslCompatibleName(const std::string &Prefix,
                                  const std::string &Middle, long Number,
                                  const std::string &Suffix,
                                  bool UseInstructionNames);
 
 std::string getIslCompatibleName(const std::string &Prefix,
                                  const std::string &Middle,
                                  const std::string &Suffix);
 
 inline llvm::DiagnosticInfoOptimizationBase &
 operator<<(llvm::DiagnosticInfoOptimizationBase &OS,
            const isl::union_map &Obj) {
   OS << stringFromIslObj(Obj);
   return OS;
 }
 
 /// Scope guard for code that allows arbitrary isl function to return an error
 /// if the max-operations quota exceeds.
 ///
 /// This allows to opt-in code sections that have known long executions times.
 /// code not in a hot path can continue to assume that no unexpected error
 /// occurs.
 ///
 /// This is typically used inside a nested IslMaxOperationsGuard scope. The
 /// IslMaxOperationsGuard defines the number of allowed base operations for some
 /// code, IslQuotaScope defines where it is allowed to return an error result.
 class IslQuotaScope final {
   isl_ctx *IslCtx;
   int OldOnError;
 
 public:
   IslQuotaScope() : IslCtx(nullptr) {}
   IslQuotaScope(const IslQuotaScope &) = delete;
   IslQuotaScope(IslQuotaScope &&Other)
       : IslCtx(Other.IslCtx), OldOnError(Other.OldOnError) {
     Other.IslCtx = nullptr;
   }
   const IslQuotaScope &operator=(IslQuotaScope &&Other) {
     std::swap(this->IslCtx, Other.IslCtx);
     std::swap(this->OldOnError, Other.OldOnError);
     return *this;
   }
 
   /// Enter a quota-aware scope.
   ///
   /// Should not be used directly. Use IslMaxOperationsGuard::enter() instead.
   explicit IslQuotaScope(isl_ctx *IslCtx, unsigned long LocalMaxOps)
       : IslCtx(IslCtx) {
     assert(IslCtx);
     assert(isl_ctx_get_max_operations(IslCtx) == 0 && "Incorrect nesting");
     if (LocalMaxOps == 0) {
       this->IslCtx = nullptr;
       return;
     }
 
     OldOnError = isl_options_get_on_error(IslCtx);
     isl_options_set_on_error(IslCtx, ISL_ON_ERROR_CONTINUE);
     isl_ctx_reset_error(IslCtx);
     isl_ctx_set_max_operations(IslCtx, LocalMaxOps);
   }
 
   ~IslQuotaScope() {
     if (!IslCtx)
       return;
 
     assert(isl_ctx_get_max_operations(IslCtx) > 0 && "Incorrect nesting");
     assert(isl_options_get_on_error(IslCtx) == ISL_ON_ERROR_CONTINUE &&
            "Incorrect nesting");
     isl_ctx_set_max_operations(IslCtx, 0);
     isl_options_set_on_error(IslCtx, OldOnError);
   }
 
   /// Return whether the current quota has exceeded.
   bool hasQuotaExceeded() const {
     if (!IslCtx)
       return false;
 
     return isl_ctx_last_error(IslCtx) == isl_error_quota;
   }
 };
 
 /// Scoped limit of ISL operations.
 ///
 /// Limits the number of ISL operations during the lifetime of this object. The
 /// idea is to use this as an RAII guard for the scope where the code is aware
 /// that ISL can return errors even when all input is valid. After leaving the
 /// scope, it will return to the error setting as it was before. That also means
 /// that the error setting should not be changed while in that scope.
 ///
 /// Such scopes are not allowed to be nested because the previous operations
 /// counter cannot be reset to the previous state, or one that adds the
 /// operations while being in the nested scope. Use therefore is only allowed
 /// while currently a no operations-limit is active.
 class IslMaxOperationsGuard final {
 private:
   /// The ISL context to set the operations limit.
   ///
   /// If set to nullptr, there is no need for any action at the end of the
   /// scope.
   isl_ctx *IslCtx;
 
   /// Maximum number of operations for the scope.
   unsigned long LocalMaxOps;
 
   /// When AutoEnter is enabled, holds the IslQuotaScope object.
   IslQuotaScope TopLevelScope;
 
 public:
   /// Enter a max operations scope.
   ///
   /// @param IslCtx      The ISL context to set the operations limit for.
   /// @param LocalMaxOps Maximum number of operations allowed in the
   ///                    scope. If set to zero, no operations limit is enforced.
   /// @param AutoEnter   If true, automatically enters an IslQuotaScope such
   ///                    that isl operations may return quota errors
   ///                    immediately. If false, only starts the operations
   ///                    counter, but isl does not return quota errors before
   ///                    calling enter().
   IslMaxOperationsGuard(isl_ctx *IslCtx, unsigned long LocalMaxOps,
                         bool AutoEnter = true)
       : IslCtx(IslCtx), LocalMaxOps(LocalMaxOps) {
     assert(IslCtx);
     assert(isl_ctx_get_max_operations(IslCtx) == 0 &&
            "Nested max operations not supported");
 
     // Users of this guard may check whether the last error was isl_error_quota.
     // Reset the last error such that a previous out-of-quota error is not
     // mistaken to have occurred in the in this quota, even if the max number of
     // operations is set to infinite (LocalMaxOps == 0).
     isl_ctx_reset_error(IslCtx);
 
     if (LocalMaxOps == 0) {
       // No limit on operations; also disable restoring on_error/max_operations.
       this->IslCtx = nullptr;
       return;
     }
 
     isl_ctx_reset_operations(IslCtx);
     TopLevelScope = enter(AutoEnter);
   }
 
   /// Enter a scope that can handle out-of-quota errors.
   ///
   /// @param AllowReturnNull Whether the scoped code can handle out-of-quota
   ///                        errors. If false, returns a dummy scope object that
   ///                        does nothing.
   IslQuotaScope enter(bool AllowReturnNull = true) {
     return AllowReturnNull && IslCtx ? IslQuotaScope(IslCtx, LocalMaxOps)
                                      : IslQuotaScope();
   }
 
   /// Return whether the current quota has exceeded.
   bool hasQuotaExceeded() const {
     if (!IslCtx)
       return false;
 
     return isl_ctx_last_error(IslCtx) == isl_error_quota;
   }
 };
 } // end namespace polly
 
 #endif

This page was automatically generated by the 2.3.7 LXR engine. The LXR team