llvm/polly/unittests/Isl/IslTest.cpp

//===- IslTest.cpp ----------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//

#include "polly/Support/GICHelper.h"
#include "polly/Support/ISLOperators.h"
#include "polly/Support/ISLTools.h"
#include "gtest/gtest.h"
#include "isl/stream.h"
#include "isl/val.h"

usingnamespacellvm;
usingnamespacepolly;

static isl::space parseSpace(isl_ctx *Ctx, const char *Str) { … }

#define SPACE(Str) …

#define SET(Str) …
#define MAP(Str) …

#define USET(Str) …
#define UMAP(Str) …

namespace isl {
inline namespace noexceptions {

static bool operator==(const isl::space &LHS, const isl::space &RHS) { … }

static bool operator==(const isl::set &LHS, const isl::set &RHS) { … }

static bool operator==(const isl::map &LHS, const isl::map &RHS) { … }

static bool operator==(const isl::union_set &LHS, const isl::union_set &RHS) { … }

static bool operator==(const isl::union_map &LHS, const isl::union_map &RHS) { … }

static bool operator==(const isl::val &LHS, const isl::val &RHS) { … }

static bool operator==(const isl::pw_aff &LHS, const isl::pw_aff &RHS) { … }
} // namespace noexceptions
} // namespace isl

namespace {

TEST(Isl, APIntToIslVal) { … }

TEST(Isl, IslValToAPInt) { … }

TEST(Isl, Operators) { … }

TEST(Isl, Foreach) { … }

TEST(ISLTools, beforeScatter) { … }

TEST(ISLTools, afterScatter) { … }

TEST(ISLTools, betweenScatter) { … }

TEST(ISLTools, singleton) { … }

TEST(ISLTools, getNumScatterDims) { … }

TEST(ISLTools, getScatterSpace) { … }

TEST(ISLTools, makeIdentityMap) { … }

TEST(ISLTools, reverseDomain) { … }

TEST(ISLTools, shiftDim) { … }

TEST(DeLICM, computeReachingWrite) { … }

TEST(DeLICM, computeArrayUnused) { … }

TEST(DeLICM, convertZoneToTimepoints) { … }

TEST(DeLICM, distribute) { … }

TEST(DeLICM, lift) { … }

TEST(DeLICM, apply) { … }

TEST(Isl, Quota) { … }

} // anonymous namespace