2018-06-23 13:03:48 +08:00
|
|
|
//===- MLIRContext.cpp - MLIR Type Classes --------------------------------===//
|
|
|
|
//
|
|
|
|
// Copyright 2019 The MLIR Authors.
|
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
// you may not use this file except in compliance with the License.
|
|
|
|
// You may obtain a copy of the License at
|
|
|
|
//
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
//
|
|
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
// See the License for the specific language governing permissions and
|
|
|
|
// limitations under the License.
|
|
|
|
// =============================================================================
|
|
|
|
|
|
|
|
#include "mlir/IR/MLIRContext.h"
|
2018-10-10 01:59:27 +08:00
|
|
|
#include "AffineExprDetail.h"
|
2018-10-10 07:39:24 +08:00
|
|
|
#include "AffineMapDetail.h"
|
2018-07-06 12:20:59 +08:00
|
|
|
#include "AttributeListStorage.h"
|
2018-06-30 09:09:29 +08:00
|
|
|
#include "mlir/IR/AffineExpr.h"
|
|
|
|
#include "mlir/IR/AffineMap.h"
|
2018-07-05 01:43:29 +08:00
|
|
|
#include "mlir/IR/Attributes.h"
|
2018-08-20 12:17:22 +08:00
|
|
|
#include "mlir/IR/Function.h"
|
2018-07-05 01:43:29 +08:00
|
|
|
#include "mlir/IR/Identifier.h"
|
2018-08-08 05:24:38 +08:00
|
|
|
#include "mlir/IR/IntegerSet.h"
|
2018-08-28 12:05:16 +08:00
|
|
|
#include "mlir/IR/Location.h"
|
2018-07-06 00:12:11 +08:00
|
|
|
#include "mlir/IR/OperationSet.h"
|
|
|
|
#include "mlir/IR/StandardOps.h"
|
2018-06-23 13:03:48 +08:00
|
|
|
#include "mlir/IR/Types.h"
|
2018-10-09 01:20:25 +08:00
|
|
|
#include "mlir/Support/MathExtras.h"
|
2018-07-05 01:43:29 +08:00
|
|
|
#include "mlir/Support/STLExtras.h"
|
2018-06-23 13:03:48 +08:00
|
|
|
#include "llvm/ADT/DenseSet.h"
|
2018-06-29 11:45:33 +08:00
|
|
|
#include "llvm/ADT/StringMap.h"
|
2018-06-23 13:03:48 +08:00
|
|
|
#include "llvm/Support/Allocator.h"
|
2018-08-02 01:18:59 +08:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2018-09-22 09:12:15 +08:00
|
|
|
|
2018-06-23 13:03:48 +08:00
|
|
|
using namespace mlir;
|
2018-10-09 01:20:25 +08:00
|
|
|
using namespace mlir::detail;
|
2018-06-23 13:03:48 +08:00
|
|
|
using namespace llvm;
|
|
|
|
|
|
|
|
namespace {
|
2018-07-24 02:44:40 +08:00
|
|
|
struct FunctionTypeKeyInfo : DenseMapInfo<FunctionType *> {
|
2018-06-23 13:03:48 +08:00
|
|
|
// Functions are uniqued based on their inputs and results.
|
2018-07-24 02:44:40 +08:00
|
|
|
using KeyTy = std::pair<ArrayRef<Type *>, ArrayRef<Type *>>;
|
|
|
|
using DenseMapInfo<FunctionType *>::getHashValue;
|
|
|
|
using DenseMapInfo<FunctionType *>::isEqual;
|
2018-06-23 13:03:48 +08:00
|
|
|
|
|
|
|
static unsigned getHashValue(KeyTy key) {
|
2018-07-24 02:44:40 +08:00
|
|
|
return hash_combine(
|
|
|
|
hash_combine_range(key.first.begin(), key.first.end()),
|
|
|
|
hash_combine_range(key.second.begin(), key.second.end()));
|
2018-06-23 13:03:48 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static bool isEqual(const KeyTy &lhs, const FunctionType *rhs) {
|
|
|
|
if (rhs == getEmptyKey() || rhs == getTombstoneKey())
|
|
|
|
return false;
|
|
|
|
return lhs == KeyTy(rhs->getInputs(), rhs->getResults());
|
|
|
|
}
|
|
|
|
};
|
2018-07-04 11:16:08 +08:00
|
|
|
|
2018-10-10 07:39:24 +08:00
|
|
|
struct AffineMapKeyInfo : DenseMapInfo<AffineMap> {
|
2018-07-04 11:16:08 +08:00
|
|
|
// Affine maps are uniqued based on their dim/symbol counts and affine
|
|
|
|
// expressions.
|
2018-10-09 04:47:18 +08:00
|
|
|
using KeyTy = std::tuple<unsigned, unsigned, ArrayRef<AffineExpr>,
|
|
|
|
ArrayRef<AffineExpr>>;
|
2018-10-10 07:39:24 +08:00
|
|
|
using DenseMapInfo<AffineMap>::getHashValue;
|
|
|
|
using DenseMapInfo<AffineMap>::isEqual;
|
2018-06-30 09:09:29 +08:00
|
|
|
|
|
|
|
static unsigned getHashValue(KeyTy key) {
|
2018-07-04 11:16:08 +08:00
|
|
|
return hash_combine(
|
2018-07-05 01:43:29 +08:00
|
|
|
std::get<0>(key), std::get<1>(key),
|
2018-07-12 12:31:07 +08:00
|
|
|
hash_combine_range(std::get<2>(key).begin(), std::get<2>(key).end()),
|
|
|
|
hash_combine_range(std::get<3>(key).begin(), std::get<3>(key).end()));
|
2018-06-30 09:09:29 +08:00
|
|
|
}
|
|
|
|
|
2018-10-10 07:39:24 +08:00
|
|
|
static bool isEqual(const KeyTy &lhs, AffineMap rhs) {
|
2018-07-04 11:16:08 +08:00
|
|
|
if (rhs == getEmptyKey() || rhs == getTombstoneKey())
|
|
|
|
return false;
|
2018-10-10 07:39:24 +08:00
|
|
|
return lhs == std::make_tuple(rhs.getNumDims(), rhs.getNumSymbols(),
|
|
|
|
rhs.getResults(), rhs.getRangeSizes());
|
2018-06-30 09:09:29 +08:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2018-07-24 02:44:40 +08:00
|
|
|
struct VectorTypeKeyInfo : DenseMapInfo<VectorType *> {
|
2018-06-23 13:03:48 +08:00
|
|
|
// Vectors are uniqued based on their element type and shape.
|
2018-07-24 02:44:40 +08:00
|
|
|
using KeyTy = std::pair<Type *, ArrayRef<unsigned>>;
|
|
|
|
using DenseMapInfo<VectorType *>::getHashValue;
|
|
|
|
using DenseMapInfo<VectorType *>::isEqual;
|
2018-06-23 13:03:48 +08:00
|
|
|
|
|
|
|
static unsigned getHashValue(KeyTy key) {
|
2018-07-24 02:44:40 +08:00
|
|
|
return hash_combine(
|
|
|
|
DenseMapInfo<Type *>::getHashValue(key.first),
|
|
|
|
hash_combine_range(key.second.begin(), key.second.end()));
|
2018-06-23 13:03:48 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static bool isEqual(const KeyTy &lhs, const VectorType *rhs) {
|
|
|
|
if (rhs == getEmptyKey() || rhs == getTombstoneKey())
|
|
|
|
return false;
|
|
|
|
return lhs == KeyTy(rhs->getElementType(), rhs->getShape());
|
|
|
|
}
|
|
|
|
};
|
2018-07-05 01:43:29 +08:00
|
|
|
|
2018-07-24 02:44:40 +08:00
|
|
|
struct RankedTensorTypeKeyInfo : DenseMapInfo<RankedTensorType *> {
|
2018-06-24 09:09:09 +08:00
|
|
|
// Ranked tensors are uniqued based on their element type and shape.
|
2018-07-24 02:44:40 +08:00
|
|
|
using KeyTy = std::pair<Type *, ArrayRef<int>>;
|
|
|
|
using DenseMapInfo<RankedTensorType *>::getHashValue;
|
|
|
|
using DenseMapInfo<RankedTensorType *>::isEqual;
|
2018-06-24 09:09:09 +08:00
|
|
|
|
|
|
|
static unsigned getHashValue(KeyTy key) {
|
2018-07-24 02:44:40 +08:00
|
|
|
return hash_combine(
|
|
|
|
DenseMapInfo<Type *>::getHashValue(key.first),
|
|
|
|
hash_combine_range(key.second.begin(), key.second.end()));
|
2018-06-24 09:09:09 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static bool isEqual(const KeyTy &lhs, const RankedTensorType *rhs) {
|
|
|
|
if (rhs == getEmptyKey() || rhs == getTombstoneKey())
|
|
|
|
return false;
|
|
|
|
return lhs == KeyTy(rhs->getElementType(), rhs->getShape());
|
|
|
|
}
|
|
|
|
};
|
2018-07-05 01:43:29 +08:00
|
|
|
|
2018-07-24 02:44:40 +08:00
|
|
|
struct MemRefTypeKeyInfo : DenseMapInfo<MemRefType *> {
|
2018-07-17 00:45:22 +08:00
|
|
|
// MemRefs are uniqued based on their element type, shape, affine map
|
|
|
|
// composition, and memory space.
|
2018-07-24 02:44:40 +08:00
|
|
|
using KeyTy =
|
2018-10-10 07:39:24 +08:00
|
|
|
std::tuple<Type *, ArrayRef<int>, ArrayRef<AffineMap>, unsigned>;
|
2018-07-24 02:44:40 +08:00
|
|
|
using DenseMapInfo<MemRefType *>::getHashValue;
|
|
|
|
using DenseMapInfo<MemRefType *>::isEqual;
|
2018-07-17 00:45:22 +08:00
|
|
|
|
|
|
|
static unsigned getHashValue(KeyTy key) {
|
|
|
|
return hash_combine(
|
2018-07-24 02:44:40 +08:00
|
|
|
DenseMapInfo<Type *>::getHashValue(std::get<0>(key)),
|
2018-07-17 00:45:22 +08:00
|
|
|
hash_combine_range(std::get<1>(key).begin(), std::get<1>(key).end()),
|
|
|
|
hash_combine_range(std::get<2>(key).begin(), std::get<2>(key).end()),
|
|
|
|
std::get<3>(key));
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool isEqual(const KeyTy &lhs, const MemRefType *rhs) {
|
|
|
|
if (rhs == getEmptyKey() || rhs == getTombstoneKey())
|
|
|
|
return false;
|
|
|
|
return lhs == std::make_tuple(rhs->getElementType(), rhs->getShape(),
|
|
|
|
rhs->getAffineMaps(), rhs->getMemorySpace());
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2018-07-24 02:44:40 +08:00
|
|
|
struct ArrayAttrKeyInfo : DenseMapInfo<ArrayAttr *> {
|
2018-07-05 01:43:29 +08:00
|
|
|
// Array attributes are uniqued based on their elements.
|
2018-07-24 02:44:40 +08:00
|
|
|
using KeyTy = ArrayRef<Attribute *>;
|
|
|
|
using DenseMapInfo<ArrayAttr *>::getHashValue;
|
|
|
|
using DenseMapInfo<ArrayAttr *>::isEqual;
|
2018-07-05 01:43:29 +08:00
|
|
|
|
|
|
|
static unsigned getHashValue(KeyTy key) {
|
|
|
|
return hash_combine_range(key.begin(), key.end());
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool isEqual(const KeyTy &lhs, const ArrayAttr *rhs) {
|
|
|
|
if (rhs == getEmptyKey() || rhs == getTombstoneKey())
|
|
|
|
return false;
|
|
|
|
return lhs == rhs->getValue();
|
|
|
|
}
|
|
|
|
};
|
2018-07-06 12:20:59 +08:00
|
|
|
|
|
|
|
struct AttributeListKeyInfo : DenseMapInfo<AttributeListStorage *> {
|
|
|
|
// Array attributes are uniqued based on their elements.
|
|
|
|
using KeyTy = ArrayRef<NamedAttribute>;
|
|
|
|
using DenseMapInfo<AttributeListStorage *>::getHashValue;
|
|
|
|
using DenseMapInfo<AttributeListStorage *>::isEqual;
|
|
|
|
|
|
|
|
static unsigned getHashValue(KeyTy key) {
|
|
|
|
return hash_combine_range(key.begin(), key.end());
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool isEqual(const KeyTy &lhs, const AttributeListStorage *rhs) {
|
|
|
|
if (rhs == getEmptyKey() || rhs == getTombstoneKey())
|
|
|
|
return false;
|
|
|
|
return lhs == rhs->getElements();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2018-06-23 13:03:48 +08:00
|
|
|
} // end anonymous namespace.
|
|
|
|
|
|
|
|
namespace mlir {
|
|
|
|
/// This is the implementation of the MLIRContext class, using the pImpl idiom.
|
|
|
|
/// This class is completely private to this file, so everything is public.
|
|
|
|
class MLIRContextImpl {
|
|
|
|
public:
|
2018-07-06 00:12:11 +08:00
|
|
|
/// This is the set of all operations that are registered with the system.
|
|
|
|
OperationSet operationSet;
|
|
|
|
|
2018-08-28 12:05:16 +08:00
|
|
|
/// We put location info into this allocator, since it is generally not
|
|
|
|
/// touched by compiler passes.
|
|
|
|
llvm::BumpPtrAllocator locationAllocator;
|
|
|
|
|
|
|
|
/// The singleton for UnknownLoc.
|
|
|
|
UnknownLoc *theUnknownLoc = nullptr;
|
|
|
|
|
|
|
|
/// These are filename locations uniqued into this MLIRContext.
|
|
|
|
llvm::StringMap<char, llvm::BumpPtrAllocator &> filenames;
|
|
|
|
|
|
|
|
/// FileLineColLoc uniquing.
|
|
|
|
DenseMap<std::tuple<const char *, unsigned, unsigned>, FileLineColLoc *>
|
|
|
|
fileLineColLocs;
|
|
|
|
|
|
|
|
/// We put immortal objects into this allocator.
|
|
|
|
llvm::BumpPtrAllocator allocator;
|
|
|
|
|
2018-08-06 12:12:29 +08:00
|
|
|
/// This is the handler to use to report diagnostics, or null if not
|
|
|
|
/// registered.
|
|
|
|
MLIRContext::DiagnosticHandlerTy diagnosticHandler;
|
2018-08-02 01:18:59 +08:00
|
|
|
|
2018-06-29 11:45:33 +08:00
|
|
|
/// These are identifiers uniqued into this MLIRContext.
|
2018-07-24 02:44:40 +08:00
|
|
|
llvm::StringMap<char, llvm::BumpPtrAllocator &> identifiers;
|
2018-06-29 11:45:33 +08:00
|
|
|
|
Eliminate "primitive" types from being a thing, splitting them into FloatType
and OtherType. Other type is now the thing that holds AffineInt, Control,
eventually Resource, Variant, String, etc. FloatType holds the floating point
types, and allows convenient query of isa<FloatType>().
This fixes issues where we allowed control to be the element type of tensor,
memref, vector. At the same time, ban AffineInt from being an element of a
vector/memref/tensor as well since we don't need it.
I updated the spec to match this as well.
PiperOrigin-RevId: 206361942
2018-07-28 04:09:58 +08:00
|
|
|
// Uniquing table for 'other' types.
|
|
|
|
OtherType *otherTypes[int(Type::Kind::LAST_OTHER_TYPE) -
|
|
|
|
int(Type::Kind::FIRST_OTHER_TYPE) + 1] = {nullptr};
|
|
|
|
|
|
|
|
// Uniquing table for 'float' types.
|
|
|
|
FloatType *floatTypes[int(Type::Kind::LAST_FLOATING_POINT_TYPE) -
|
|
|
|
int(Type::Kind::FIRST_FLOATING_POINT_TYPE) + 1] = {
|
2018-07-24 02:44:40 +08:00
|
|
|
nullptr};
|
2018-06-23 13:03:48 +08:00
|
|
|
|
2018-06-30 09:09:29 +08:00
|
|
|
// Affine map uniquing.
|
2018-10-10 07:39:24 +08:00
|
|
|
using AffineMapSet = DenseSet<AffineMap, AffineMapKeyInfo>;
|
2018-06-30 09:09:29 +08:00
|
|
|
AffineMapSet affineMaps;
|
|
|
|
|
2018-07-04 12:34:58 +08:00
|
|
|
// Affine binary op expression uniquing. Figure out uniquing of dimensional
|
2018-07-04 11:16:08 +08:00
|
|
|
// or symbolic identifiers.
|
2018-10-09 04:47:18 +08:00
|
|
|
DenseMap<std::tuple<unsigned, AffineExpr, AffineExpr>, AffineExpr>
|
2018-07-04 11:16:08 +08:00
|
|
|
affineExprs;
|
|
|
|
|
2018-10-09 04:47:18 +08:00
|
|
|
// Uniqui'ing of AffineDimExpr, AffineSymbolExpr's by their position.
|
2018-10-10 01:59:27 +08:00
|
|
|
std::vector<AffineDimExprStorage *> dimExprs;
|
|
|
|
std::vector<AffineSymbolExprStorage *> symbolExprs;
|
2018-07-25 13:34:09 +08:00
|
|
|
|
2018-10-10 01:59:27 +08:00
|
|
|
// Uniqui'ing of AffineConstantExprStorage using constant value as key.
|
|
|
|
DenseMap<int64_t, AffineConstantExprStorage *> constExprs;
|
2018-07-25 13:34:09 +08:00
|
|
|
|
2018-06-30 13:08:05 +08:00
|
|
|
/// Integer type uniquing.
|
2018-07-24 02:44:40 +08:00
|
|
|
DenseMap<unsigned, IntegerType *> integers;
|
2018-06-30 13:08:05 +08:00
|
|
|
|
2018-06-23 13:03:48 +08:00
|
|
|
/// Function type uniquing.
|
2018-07-24 02:44:40 +08:00
|
|
|
using FunctionTypeSet = DenseSet<FunctionType *, FunctionTypeKeyInfo>;
|
2018-06-23 13:03:48 +08:00
|
|
|
FunctionTypeSet functions;
|
|
|
|
|
|
|
|
/// Vector type uniquing.
|
2018-07-24 02:44:40 +08:00
|
|
|
using VectorTypeSet = DenseSet<VectorType *, VectorTypeKeyInfo>;
|
2018-06-23 13:03:48 +08:00
|
|
|
VectorTypeSet vectors;
|
|
|
|
|
2018-06-24 09:09:09 +08:00
|
|
|
/// Ranked tensor type uniquing.
|
2018-07-24 02:44:40 +08:00
|
|
|
using RankedTensorTypeSet =
|
|
|
|
DenseSet<RankedTensorType *, RankedTensorTypeKeyInfo>;
|
2018-06-24 09:09:09 +08:00
|
|
|
RankedTensorTypeSet rankedTensors;
|
|
|
|
|
|
|
|
/// Unranked tensor type uniquing.
|
2018-07-24 02:44:40 +08:00
|
|
|
DenseMap<Type *, UnrankedTensorType *> unrankedTensors;
|
2018-06-24 09:09:09 +08:00
|
|
|
|
2018-07-17 00:45:22 +08:00
|
|
|
/// MemRef type uniquing.
|
2018-07-24 02:44:40 +08:00
|
|
|
using MemRefTypeSet = DenseSet<MemRefType *, MemRefTypeKeyInfo>;
|
2018-07-17 00:45:22 +08:00
|
|
|
MemRefTypeSet memrefs;
|
|
|
|
|
2018-07-05 01:43:29 +08:00
|
|
|
// Attribute uniquing.
|
2018-07-24 02:44:40 +08:00
|
|
|
BoolAttr *boolAttrs[2] = {nullptr};
|
|
|
|
DenseMap<int64_t, IntegerAttr *> integerAttrs;
|
|
|
|
DenseMap<int64_t, FloatAttr *> floatAttrs;
|
|
|
|
StringMap<StringAttr *> stringAttrs;
|
|
|
|
using ArrayAttrSet = DenseSet<ArrayAttr *, ArrayAttrKeyInfo>;
|
2018-07-05 01:43:29 +08:00
|
|
|
ArrayAttrSet arrayAttrs;
|
2018-10-10 07:39:24 +08:00
|
|
|
DenseMap<AffineMap, AffineMapAttr *> affineMapAttrs;
|
2018-08-03 16:54:46 +08:00
|
|
|
DenseMap<Type *, TypeAttr *> typeAttrs;
|
2018-07-06 12:20:59 +08:00
|
|
|
using AttributeListSet =
|
|
|
|
DenseSet<AttributeListStorage *, AttributeListKeyInfo>;
|
|
|
|
AttributeListSet attributeLists;
|
2018-08-22 08:55:22 +08:00
|
|
|
DenseMap<const Function *, FunctionAttr *> functionAttrs;
|
2018-06-23 13:03:48 +08:00
|
|
|
|
|
|
|
public:
|
2018-08-28 12:05:16 +08:00
|
|
|
MLIRContextImpl() : filenames(locationAllocator), identifiers(allocator) {
|
2018-07-06 00:12:11 +08:00
|
|
|
registerStandardOperations(operationSet);
|
|
|
|
}
|
2018-06-29 11:45:33 +08:00
|
|
|
|
2018-06-23 13:03:48 +08:00
|
|
|
/// Copy the specified array of elements into memory managed by our bump
|
|
|
|
/// pointer allocator. This assumes the elements are all PODs.
|
2018-10-04 06:36:53 +08:00
|
|
|
template <typename T> ArrayRef<T> copyInto(ArrayRef<T> elements) {
|
2018-06-23 13:03:48 +08:00
|
|
|
auto result = allocator.Allocate<T>(elements.size());
|
|
|
|
std::uninitialized_copy(elements.begin(), elements.end(), result);
|
|
|
|
return ArrayRef<T>(result, elements.size());
|
|
|
|
}
|
|
|
|
};
|
|
|
|
} // end namespace mlir
|
|
|
|
|
2018-09-22 09:12:15 +08:00
|
|
|
MLIRContext::MLIRContext() : impl(new MLIRContextImpl()) {
|
|
|
|
initializeAllRegisteredOps(this);
|
|
|
|
}
|
2018-06-23 13:03:48 +08:00
|
|
|
|
2018-07-24 02:44:40 +08:00
|
|
|
MLIRContext::~MLIRContext() {}
|
2018-06-23 13:03:48 +08:00
|
|
|
|
2018-08-02 01:18:59 +08:00
|
|
|
/// Register an issue handler with this LLVM context. The issue handler is
|
|
|
|
/// passed location information if present (nullptr if not) along with a
|
|
|
|
/// message and a boolean that indicates whether this is an error or warning.
|
|
|
|
void MLIRContext::registerDiagnosticHandler(
|
2018-08-06 12:12:29 +08:00
|
|
|
const DiagnosticHandlerTy &handler) {
|
|
|
|
getImpl().diagnosticHandler = handler;
|
2018-08-02 01:18:59 +08:00
|
|
|
}
|
|
|
|
|
2018-08-21 23:42:19 +08:00
|
|
|
/// Return the current diagnostic handler, or null if none is present.
|
|
|
|
auto MLIRContext::getDiagnosticHandler() const -> DiagnosticHandlerTy {
|
|
|
|
return getImpl().diagnosticHandler;
|
|
|
|
}
|
|
|
|
|
2018-08-02 01:18:59 +08:00
|
|
|
/// This emits a diagnostic using the registered issue handle if present, or
|
|
|
|
/// with the default behavior if not. The MLIR compiler should not generally
|
|
|
|
/// interact with this, it should use methods on Operation instead.
|
2018-08-28 12:05:16 +08:00
|
|
|
void MLIRContext::emitDiagnostic(Location *location, const llvm::Twine &message,
|
2018-08-06 12:12:29 +08:00
|
|
|
DiagnosticKind kind) const {
|
2018-08-02 01:18:59 +08:00
|
|
|
// If we had a handler registered, emit the diagnostic using it.
|
2018-08-06 12:12:29 +08:00
|
|
|
auto handler = getImpl().diagnosticHandler;
|
|
|
|
if (handler && location)
|
|
|
|
return handler(location, message.str(), kind);
|
2018-08-02 01:18:59 +08:00
|
|
|
|
2018-08-06 12:12:29 +08:00
|
|
|
// The default behavior for notes and warnings is to ignore them.
|
|
|
|
if (kind != DiagnosticKind::Error)
|
2018-08-02 01:18:59 +08:00
|
|
|
return;
|
|
|
|
|
2018-09-03 13:01:45 +08:00
|
|
|
auto &os = llvm::errs();
|
|
|
|
|
|
|
|
if (auto fileLoc = dyn_cast<FileLineColLoc>(location))
|
|
|
|
os << fileLoc->getFilename() << ':' << fileLoc->getLine() << ':'
|
|
|
|
<< fileLoc->getColumn() << ": ";
|
|
|
|
|
|
|
|
os << "error: ";
|
2018-08-28 12:05:16 +08:00
|
|
|
|
2018-08-02 01:18:59 +08:00
|
|
|
// The default behavior for errors is to emit them to stderr and exit.
|
2018-09-03 13:01:45 +08:00
|
|
|
os << message.str() << '\n';
|
|
|
|
os.flush();
|
2018-08-02 01:18:59 +08:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
2018-07-06 00:12:11 +08:00
|
|
|
/// Return the operation set associated with the specified MLIRContext object.
|
|
|
|
OperationSet &OperationSet::get(MLIRContext *context) {
|
|
|
|
return context->getImpl().operationSet;
|
|
|
|
}
|
2018-06-23 13:03:48 +08:00
|
|
|
|
2018-07-07 01:46:19 +08:00
|
|
|
/// If this operation has a registered operation description in the
|
|
|
|
/// OperationSet, return it. Otherwise return null.
|
2018-08-02 01:18:59 +08:00
|
|
|
const AbstractOperation *Operation::getAbstractOperation() const {
|
|
|
|
return OperationSet::get(getContext()).lookup(getName().str());
|
2018-07-07 01:46:19 +08:00
|
|
|
}
|
|
|
|
|
2018-06-29 11:45:33 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2018-07-05 01:43:29 +08:00
|
|
|
// Identifier uniquing
|
2018-06-29 11:45:33 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
/// Return an identifier for the specified string.
|
|
|
|
Identifier Identifier::get(StringRef str, const MLIRContext *context) {
|
|
|
|
assert(!str.empty() && "Cannot create an empty identifier");
|
|
|
|
assert(str.find('\0') == StringRef::npos &&
|
|
|
|
"Cannot create an identifier with a nul character");
|
|
|
|
|
|
|
|
auto &impl = context->getImpl();
|
|
|
|
auto it = impl.identifiers.insert({str, char()}).first;
|
|
|
|
return Identifier(it->getKeyData());
|
|
|
|
}
|
|
|
|
|
2018-08-28 12:05:16 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Location uniquing
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
UnknownLoc *UnknownLoc::get(MLIRContext *context) {
|
|
|
|
auto &impl = context->getImpl();
|
|
|
|
if (auto *result = impl.theUnknownLoc)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
impl.theUnknownLoc = impl.allocator.Allocate<UnknownLoc>();
|
|
|
|
new (impl.theUnknownLoc) UnknownLoc();
|
|
|
|
return impl.theUnknownLoc;
|
|
|
|
}
|
|
|
|
|
|
|
|
UniquedFilename UniquedFilename::get(StringRef filename, MLIRContext *context) {
|
|
|
|
auto &impl = context->getImpl();
|
|
|
|
auto it = impl.filenames.insert({filename, char()}).first;
|
|
|
|
return UniquedFilename(it->getKeyData());
|
|
|
|
}
|
|
|
|
|
|
|
|
FileLineColLoc *FileLineColLoc::get(UniquedFilename filename, unsigned line,
|
|
|
|
unsigned column, MLIRContext *context) {
|
|
|
|
auto &impl = context->getImpl();
|
|
|
|
auto &entry =
|
|
|
|
impl.fileLineColLocs[std::make_tuple(filename.data(), line, column)];
|
|
|
|
if (!entry) {
|
|
|
|
entry = impl.allocator.Allocate<FileLineColLoc>();
|
|
|
|
new (entry) FileLineColLoc(filename, line, column);
|
|
|
|
}
|
|
|
|
|
|
|
|
return entry;
|
|
|
|
}
|
|
|
|
|
2018-06-29 11:45:33 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2018-07-05 01:43:29 +08:00
|
|
|
// Type uniquing
|
2018-06-29 11:45:33 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
Eliminate "primitive" types from being a thing, splitting them into FloatType
and OtherType. Other type is now the thing that holds AffineInt, Control,
eventually Resource, Variant, String, etc. FloatType holds the floating point
types, and allows convenient query of isa<FloatType>().
This fixes issues where we allowed control to be the element type of tensor,
memref, vector. At the same time, ban AffineInt from being an element of a
vector/memref/tensor as well since we don't need it.
I updated the spec to match this as well.
PiperOrigin-RevId: 206361942
2018-07-28 04:09:58 +08:00
|
|
|
IntegerType *IntegerType::get(unsigned width, MLIRContext *context) {
|
|
|
|
auto &impl = context->getImpl();
|
|
|
|
|
|
|
|
auto *&result = impl.integers[width];
|
|
|
|
if (!result) {
|
|
|
|
result = impl.allocator.Allocate<IntegerType>();
|
|
|
|
new (result) IntegerType(width, context);
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
FloatType *FloatType::get(Kind kind, MLIRContext *context) {
|
|
|
|
assert(kind >= Kind::FIRST_FLOATING_POINT_TYPE &&
|
|
|
|
kind <= Kind::LAST_FLOATING_POINT_TYPE && "Not an FP type kind");
|
2018-06-23 13:03:48 +08:00
|
|
|
auto &impl = context->getImpl();
|
|
|
|
|
|
|
|
// We normally have these types.
|
Eliminate "primitive" types from being a thing, splitting them into FloatType
and OtherType. Other type is now the thing that holds AffineInt, Control,
eventually Resource, Variant, String, etc. FloatType holds the floating point
types, and allows convenient query of isa<FloatType>().
This fixes issues where we allowed control to be the element type of tensor,
memref, vector. At the same time, ban AffineInt from being an element of a
vector/memref/tensor as well since we don't need it.
I updated the spec to match this as well.
PiperOrigin-RevId: 206361942
2018-07-28 04:09:58 +08:00
|
|
|
auto *&entry =
|
|
|
|
impl.floatTypes[(int)kind - int(Kind::FIRST_FLOATING_POINT_TYPE)];
|
|
|
|
if (entry)
|
|
|
|
return entry;
|
2018-06-23 13:03:48 +08:00
|
|
|
|
|
|
|
// On the first use, we allocate them into the bump pointer.
|
Eliminate "primitive" types from being a thing, splitting them into FloatType
and OtherType. Other type is now the thing that holds AffineInt, Control,
eventually Resource, Variant, String, etc. FloatType holds the floating point
types, and allows convenient query of isa<FloatType>().
This fixes issues where we allowed control to be the element type of tensor,
memref, vector. At the same time, ban AffineInt from being an element of a
vector/memref/tensor as well since we don't need it.
I updated the spec to match this as well.
PiperOrigin-RevId: 206361942
2018-07-28 04:09:58 +08:00
|
|
|
auto *ptr = impl.allocator.Allocate<FloatType>();
|
2018-06-23 13:03:48 +08:00
|
|
|
|
|
|
|
// Initialize the memory using placement new.
|
Eliminate "primitive" types from being a thing, splitting them into FloatType
and OtherType. Other type is now the thing that holds AffineInt, Control,
eventually Resource, Variant, String, etc. FloatType holds the floating point
types, and allows convenient query of isa<FloatType>().
This fixes issues where we allowed control to be the element type of tensor,
memref, vector. At the same time, ban AffineInt from being an element of a
vector/memref/tensor as well since we don't need it.
I updated the spec to match this as well.
PiperOrigin-RevId: 206361942
2018-07-28 04:09:58 +08:00
|
|
|
new (ptr) FloatType(kind, context);
|
2018-06-23 13:03:48 +08:00
|
|
|
|
|
|
|
// Cache and return it.
|
Eliminate "primitive" types from being a thing, splitting them into FloatType
and OtherType. Other type is now the thing that holds AffineInt, Control,
eventually Resource, Variant, String, etc. FloatType holds the floating point
types, and allows convenient query of isa<FloatType>().
This fixes issues where we allowed control to be the element type of tensor,
memref, vector. At the same time, ban AffineInt from being an element of a
vector/memref/tensor as well since we don't need it.
I updated the spec to match this as well.
PiperOrigin-RevId: 206361942
2018-07-28 04:09:58 +08:00
|
|
|
return entry = ptr;
|
2018-06-23 13:03:48 +08:00
|
|
|
}
|
|
|
|
|
Eliminate "primitive" types from being a thing, splitting them into FloatType
and OtherType. Other type is now the thing that holds AffineInt, Control,
eventually Resource, Variant, String, etc. FloatType holds the floating point
types, and allows convenient query of isa<FloatType>().
This fixes issues where we allowed control to be the element type of tensor,
memref, vector. At the same time, ban AffineInt from being an element of a
vector/memref/tensor as well since we don't need it.
I updated the spec to match this as well.
PiperOrigin-RevId: 206361942
2018-07-28 04:09:58 +08:00
|
|
|
OtherType *OtherType::get(Kind kind, MLIRContext *context) {
|
|
|
|
assert(kind >= Kind::FIRST_OTHER_TYPE && kind <= Kind::LAST_OTHER_TYPE &&
|
|
|
|
"Not an 'other' type kind");
|
2018-06-30 13:08:05 +08:00
|
|
|
auto &impl = context->getImpl();
|
|
|
|
|
Eliminate "primitive" types from being a thing, splitting them into FloatType
and OtherType. Other type is now the thing that holds AffineInt, Control,
eventually Resource, Variant, String, etc. FloatType holds the floating point
types, and allows convenient query of isa<FloatType>().
This fixes issues where we allowed control to be the element type of tensor,
memref, vector. At the same time, ban AffineInt from being an element of a
vector/memref/tensor as well since we don't need it.
I updated the spec to match this as well.
PiperOrigin-RevId: 206361942
2018-07-28 04:09:58 +08:00
|
|
|
// We normally have these types.
|
|
|
|
auto *&entry = impl.otherTypes[(int)kind - int(Kind::FIRST_OTHER_TYPE)];
|
|
|
|
if (entry)
|
|
|
|
return entry;
|
2018-06-30 13:08:05 +08:00
|
|
|
|
Eliminate "primitive" types from being a thing, splitting them into FloatType
and OtherType. Other type is now the thing that holds AffineInt, Control,
eventually Resource, Variant, String, etc. FloatType holds the floating point
types, and allows convenient query of isa<FloatType>().
This fixes issues where we allowed control to be the element type of tensor,
memref, vector. At the same time, ban AffineInt from being an element of a
vector/memref/tensor as well since we don't need it.
I updated the spec to match this as well.
PiperOrigin-RevId: 206361942
2018-07-28 04:09:58 +08:00
|
|
|
// On the first use, we allocate them into the bump pointer.
|
|
|
|
auto *ptr = impl.allocator.Allocate<OtherType>();
|
|
|
|
|
|
|
|
// Initialize the memory using placement new.
|
|
|
|
new (ptr) OtherType(kind, context);
|
|
|
|
|
|
|
|
// Cache and return it.
|
|
|
|
return entry = ptr;
|
2018-06-23 13:03:48 +08:00
|
|
|
}
|
|
|
|
|
2018-07-24 02:44:40 +08:00
|
|
|
FunctionType *FunctionType::get(ArrayRef<Type *> inputs,
|
|
|
|
ArrayRef<Type *> results,
|
2018-06-23 13:03:48 +08:00
|
|
|
MLIRContext *context) {
|
|
|
|
auto &impl = context->getImpl();
|
|
|
|
|
|
|
|
// Look to see if we already have this function type.
|
|
|
|
FunctionTypeKeyInfo::KeyTy key(inputs, results);
|
|
|
|
auto existing = impl.functions.insert_as(nullptr, key);
|
|
|
|
|
|
|
|
// If we already have it, return that value.
|
|
|
|
if (!existing.second)
|
|
|
|
return *existing.first;
|
|
|
|
|
|
|
|
// On the first use, we allocate them into the bump pointer.
|
|
|
|
auto *result = impl.allocator.Allocate<FunctionType>();
|
|
|
|
|
|
|
|
// Copy the inputs and results into the bump pointer.
|
2018-07-24 02:44:40 +08:00
|
|
|
SmallVector<Type *, 16> types;
|
|
|
|
types.reserve(inputs.size() + results.size());
|
2018-06-23 13:03:48 +08:00
|
|
|
types.append(inputs.begin(), inputs.end());
|
|
|
|
types.append(results.begin(), results.end());
|
2018-07-24 02:44:40 +08:00
|
|
|
auto typesList = impl.copyInto(ArrayRef<Type *>(types));
|
2018-06-23 13:03:48 +08:00
|
|
|
|
|
|
|
// Initialize the memory using placement new.
|
2018-07-24 02:44:40 +08:00
|
|
|
new (result)
|
|
|
|
FunctionType(typesList.data(), inputs.size(), results.size(), context);
|
2018-06-23 13:03:48 +08:00
|
|
|
|
|
|
|
// Cache and return it.
|
|
|
|
return *existing.first = result;
|
|
|
|
}
|
|
|
|
|
|
|
|
VectorType *VectorType::get(ArrayRef<unsigned> shape, Type *elementType) {
|
|
|
|
assert(!shape.empty() && "vector types must have at least one dimension");
|
Eliminate "primitive" types from being a thing, splitting them into FloatType
and OtherType. Other type is now the thing that holds AffineInt, Control,
eventually Resource, Variant, String, etc. FloatType holds the floating point
types, and allows convenient query of isa<FloatType>().
This fixes issues where we allowed control to be the element type of tensor,
memref, vector. At the same time, ban AffineInt from being an element of a
vector/memref/tensor as well since we don't need it.
I updated the spec to match this as well.
PiperOrigin-RevId: 206361942
2018-07-28 04:09:58 +08:00
|
|
|
assert((isa<FloatType>(elementType) || isa<IntegerType>(elementType)) &&
|
2018-06-23 13:03:48 +08:00
|
|
|
"vectors elements must be primitives");
|
|
|
|
|
|
|
|
auto *context = elementType->getContext();
|
|
|
|
auto &impl = context->getImpl();
|
|
|
|
|
|
|
|
// Look to see if we already have this vector type.
|
|
|
|
VectorTypeKeyInfo::KeyTy key(elementType, shape);
|
|
|
|
auto existing = impl.vectors.insert_as(nullptr, key);
|
|
|
|
|
|
|
|
// If we already have it, return that value.
|
|
|
|
if (!existing.second)
|
|
|
|
return *existing.first;
|
|
|
|
|
|
|
|
// On the first use, we allocate them into the bump pointer.
|
|
|
|
auto *result = impl.allocator.Allocate<VectorType>();
|
|
|
|
|
|
|
|
// Copy the shape into the bump pointer.
|
|
|
|
shape = impl.copyInto(shape);
|
|
|
|
|
|
|
|
// Initialize the memory using placement new.
|
2018-07-24 02:48:22 +08:00
|
|
|
new (result) VectorType(shape, elementType, context);
|
2018-06-23 13:03:48 +08:00
|
|
|
|
|
|
|
// Cache and return it.
|
|
|
|
return *existing.first = result;
|
|
|
|
}
|
2018-06-24 09:09:09 +08:00
|
|
|
|
|
|
|
RankedTensorType *RankedTensorType::get(ArrayRef<int> shape,
|
|
|
|
Type *elementType) {
|
|
|
|
auto *context = elementType->getContext();
|
|
|
|
auto &impl = context->getImpl();
|
|
|
|
|
|
|
|
// Look to see if we already have this ranked tensor type.
|
|
|
|
RankedTensorTypeKeyInfo::KeyTy key(elementType, shape);
|
|
|
|
auto existing = impl.rankedTensors.insert_as(nullptr, key);
|
|
|
|
|
|
|
|
// If we already have it, return that value.
|
|
|
|
if (!existing.second)
|
|
|
|
return *existing.first;
|
|
|
|
|
|
|
|
// On the first use, we allocate them into the bump pointer.
|
|
|
|
auto *result = impl.allocator.Allocate<RankedTensorType>();
|
|
|
|
|
|
|
|
// Copy the shape into the bump pointer.
|
|
|
|
shape = impl.copyInto(shape);
|
|
|
|
|
|
|
|
// Initialize the memory using placement new.
|
|
|
|
new (result) RankedTensorType(shape, elementType, context);
|
|
|
|
|
|
|
|
// Cache and return it.
|
|
|
|
return *existing.first = result;
|
|
|
|
}
|
|
|
|
|
|
|
|
UnrankedTensorType *UnrankedTensorType::get(Type *elementType) {
|
|
|
|
auto *context = elementType->getContext();
|
|
|
|
auto &impl = context->getImpl();
|
|
|
|
|
|
|
|
// Look to see if we already have this unranked tensor type.
|
2018-07-05 01:43:29 +08:00
|
|
|
auto *&result = impl.unrankedTensors[elementType];
|
2018-06-24 09:09:09 +08:00
|
|
|
|
|
|
|
// If we already have it, return that value.
|
2018-07-05 01:43:29 +08:00
|
|
|
if (result)
|
|
|
|
return result;
|
2018-06-24 09:09:09 +08:00
|
|
|
|
|
|
|
// On the first use, we allocate them into the bump pointer.
|
2018-07-05 01:43:29 +08:00
|
|
|
result = impl.allocator.Allocate<UnrankedTensorType>();
|
2018-06-24 09:09:09 +08:00
|
|
|
|
|
|
|
// Initialize the memory using placement new.
|
|
|
|
new (result) UnrankedTensorType(elementType, context);
|
2018-07-05 01:43:29 +08:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2018-07-17 00:45:22 +08:00
|
|
|
MemRefType *MemRefType::get(ArrayRef<int> shape, Type *elementType,
|
2018-10-10 07:39:24 +08:00
|
|
|
ArrayRef<AffineMap> affineMapComposition,
|
2018-07-17 00:45:22 +08:00
|
|
|
unsigned memorySpace) {
|
|
|
|
auto *context = elementType->getContext();
|
|
|
|
auto &impl = context->getImpl();
|
|
|
|
|
|
|
|
// Look to see if we already have this memref type.
|
2018-07-24 02:44:40 +08:00
|
|
|
auto key =
|
|
|
|
std::make_tuple(elementType, shape, affineMapComposition, memorySpace);
|
2018-07-17 00:45:22 +08:00
|
|
|
auto existing = impl.memrefs.insert_as(nullptr, key);
|
|
|
|
|
|
|
|
// If we already have it, return that value.
|
|
|
|
if (!existing.second)
|
|
|
|
return *existing.first;
|
|
|
|
|
|
|
|
// On the first use, we allocate them into the bump pointer.
|
|
|
|
auto *result = impl.allocator.Allocate<MemRefType>();
|
|
|
|
|
|
|
|
// Copy the shape into the bump pointer.
|
|
|
|
shape = impl.copyInto(shape);
|
|
|
|
|
|
|
|
// Copy the affine map composition into the bump pointer.
|
|
|
|
// TODO(andydavis) Assert that the structure of the composition is valid.
|
2018-07-24 02:44:40 +08:00
|
|
|
affineMapComposition =
|
2018-10-10 07:39:24 +08:00
|
|
|
impl.copyInto(ArrayRef<AffineMap>(affineMapComposition));
|
2018-07-17 00:45:22 +08:00
|
|
|
|
|
|
|
// Initialize the memory using placement new.
|
|
|
|
new (result) MemRefType(shape, elementType, affineMapComposition, memorySpace,
|
|
|
|
context);
|
|
|
|
// Cache and return it.
|
|
|
|
return *existing.first = result;
|
|
|
|
}
|
|
|
|
|
2018-07-05 01:43:29 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Attribute uniquing
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
BoolAttr *BoolAttr::get(bool value, MLIRContext *context) {
|
|
|
|
auto *&result = context->getImpl().boolAttrs[value];
|
|
|
|
if (result)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
result = context->getImpl().allocator.Allocate<BoolAttr>();
|
|
|
|
new (result) BoolAttr(value);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
IntegerAttr *IntegerAttr::get(int64_t value, MLIRContext *context) {
|
|
|
|
auto *&result = context->getImpl().integerAttrs[value];
|
|
|
|
if (result)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
result = context->getImpl().allocator.Allocate<IntegerAttr>();
|
|
|
|
new (result) IntegerAttr(value);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
FloatAttr *FloatAttr::get(double value, MLIRContext *context) {
|
|
|
|
// We hash based on the bit representation of the double to ensure we don't
|
|
|
|
// merge things like -0.0 and 0.0 in the hash comparison.
|
|
|
|
union {
|
|
|
|
double floatValue;
|
|
|
|
int64_t intValue;
|
|
|
|
};
|
|
|
|
floatValue = value;
|
|
|
|
|
|
|
|
auto *&result = context->getImpl().floatAttrs[intValue];
|
|
|
|
if (result)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
result = context->getImpl().allocator.Allocate<FloatAttr>();
|
|
|
|
new (result) FloatAttr(value);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
StringAttr *StringAttr::get(StringRef bytes, MLIRContext *context) {
|
|
|
|
auto it = context->getImpl().stringAttrs.insert({bytes, nullptr}).first;
|
|
|
|
|
|
|
|
if (it->second)
|
|
|
|
return it->second;
|
|
|
|
|
|
|
|
auto result = context->getImpl().allocator.Allocate<StringAttr>();
|
|
|
|
new (result) StringAttr(it->first());
|
|
|
|
it->second = result;
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2018-07-24 02:44:40 +08:00
|
|
|
ArrayAttr *ArrayAttr::get(ArrayRef<Attribute *> value, MLIRContext *context) {
|
2018-07-05 01:43:29 +08:00
|
|
|
auto &impl = context->getImpl();
|
|
|
|
|
|
|
|
// Look to see if we already have this.
|
|
|
|
auto existing = impl.arrayAttrs.insert_as(nullptr, value);
|
|
|
|
|
|
|
|
// If we already have it, return that value.
|
|
|
|
if (!existing.second)
|
|
|
|
return *existing.first;
|
|
|
|
|
|
|
|
// On the first use, we allocate them into the bump pointer.
|
|
|
|
auto *result = impl.allocator.Allocate<ArrayAttr>();
|
|
|
|
|
|
|
|
// Copy the elements into the bump pointer.
|
|
|
|
value = impl.copyInto(value);
|
|
|
|
|
2018-08-21 23:42:19 +08:00
|
|
|
// Check to see if any of the elements have a function attr.
|
|
|
|
bool hasFunctionAttr = false;
|
|
|
|
for (auto *elt : value)
|
|
|
|
if (elt->isOrContainsFunction()) {
|
|
|
|
hasFunctionAttr = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2018-07-05 01:43:29 +08:00
|
|
|
// Initialize the memory using placement new.
|
2018-08-21 23:42:19 +08:00
|
|
|
new (result) ArrayAttr(value, hasFunctionAttr);
|
2018-06-24 09:09:09 +08:00
|
|
|
|
|
|
|
// Cache and return it.
|
2018-07-05 01:43:29 +08:00
|
|
|
return *existing.first = result;
|
2018-06-24 09:09:09 +08:00
|
|
|
}
|
2018-06-30 09:09:29 +08:00
|
|
|
|
2018-10-10 07:39:24 +08:00
|
|
|
AffineMapAttr *AffineMapAttr::get(AffineMap value) {
|
|
|
|
auto *context = value.getResult(0).getContext();
|
|
|
|
auto &result = context->getImpl().affineMapAttrs[value];
|
2018-07-19 07:29:21 +08:00
|
|
|
if (result)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
result = context->getImpl().allocator.Allocate<AffineMapAttr>();
|
|
|
|
new (result) AffineMapAttr(value);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2018-08-03 16:54:46 +08:00
|
|
|
TypeAttr *TypeAttr::get(Type *type, MLIRContext *context) {
|
|
|
|
auto *&result = context->getImpl().typeAttrs[type];
|
|
|
|
if (result)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
result = context->getImpl().allocator.Allocate<TypeAttr>();
|
|
|
|
new (result) TypeAttr(type);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2018-08-22 08:55:22 +08:00
|
|
|
FunctionAttr *FunctionAttr::get(const Function *value, MLIRContext *context) {
|
|
|
|
assert(value && "Cannot get FunctionAttr for a null function");
|
|
|
|
|
2018-08-20 12:17:22 +08:00
|
|
|
auto *&result = context->getImpl().functionAttrs[value];
|
|
|
|
if (result)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
result = context->getImpl().allocator.Allocate<FunctionAttr>();
|
2018-08-22 08:55:22 +08:00
|
|
|
new (result) FunctionAttr(const_cast<Function *>(value));
|
2018-08-20 12:17:22 +08:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2018-08-22 08:55:22 +08:00
|
|
|
FunctionType *FunctionAttr::getType() const { return getValue()->getType(); }
|
|
|
|
|
2018-08-20 12:17:22 +08:00
|
|
|
/// This function is used by the internals of the Function class to null out
|
|
|
|
/// attributes refering to functions that are about to be deleted.
|
|
|
|
void FunctionAttr::dropFunctionReference(Function *value) {
|
|
|
|
// Check to see if there was an attribute referring to this function.
|
|
|
|
auto &functionAttrs = value->getContext()->getImpl().functionAttrs;
|
|
|
|
|
|
|
|
// If not, then we're done.
|
|
|
|
auto it = functionAttrs.find(value);
|
|
|
|
if (it == functionAttrs.end())
|
|
|
|
return;
|
|
|
|
|
|
|
|
// If so, null out the function reference in the attribute (to avoid dangling
|
|
|
|
// pointers) and remove the entry from the map so the map doesn't contain
|
|
|
|
// dangling keys.
|
|
|
|
it->second->value = nullptr;
|
|
|
|
functionAttrs.erase(it);
|
|
|
|
}
|
|
|
|
|
2018-07-06 12:20:59 +08:00
|
|
|
/// Perform a three-way comparison between the names of the specified
|
|
|
|
/// NamedAttributes.
|
|
|
|
static int compareNamedAttributes(const NamedAttribute *lhs,
|
|
|
|
const NamedAttribute *rhs) {
|
|
|
|
return lhs->first.str().compare(rhs->first.str());
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Given a list of NamedAttribute's, canonicalize the list (sorting
|
|
|
|
/// by name) and return the unique'd result. Note that the empty list is
|
|
|
|
/// represented with a null pointer.
|
|
|
|
AttributeListStorage *AttributeListStorage::get(ArrayRef<NamedAttribute> attrs,
|
|
|
|
MLIRContext *context) {
|
|
|
|
// We need to sort the element list to canonicalize it, but we also don't want
|
|
|
|
// to do a ton of work in the super common case where the element list is
|
|
|
|
// already sorted.
|
|
|
|
SmallVector<NamedAttribute, 8> storage;
|
|
|
|
switch (attrs.size()) {
|
|
|
|
case 0:
|
|
|
|
// An empty list is represented with a null pointer.
|
|
|
|
return nullptr;
|
|
|
|
case 1:
|
|
|
|
// A single element is already sorted.
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
// Don't invoke a general sort for two element case.
|
|
|
|
if (attrs[0].first.str() > attrs[1].first.str()) {
|
|
|
|
storage.push_back(attrs[1]);
|
|
|
|
storage.push_back(attrs[0]);
|
|
|
|
attrs = storage;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
// Check to see they are sorted already.
|
|
|
|
bool isSorted = true;
|
|
|
|
for (unsigned i = 0, e = attrs.size() - 1; i != e; ++i) {
|
|
|
|
if (attrs[i].first.str() > attrs[i + 1].first.str()) {
|
|
|
|
isSorted = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// If not, do a general sort.
|
|
|
|
if (!isSorted) {
|
|
|
|
storage.append(attrs.begin(), attrs.end());
|
|
|
|
llvm::array_pod_sort(storage.begin(), storage.end(),
|
|
|
|
compareNamedAttributes);
|
|
|
|
attrs = storage;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Ok, now that we've canonicalized our attributes, unique them.
|
|
|
|
auto &impl = context->getImpl();
|
|
|
|
|
|
|
|
// Look to see if we already have this.
|
|
|
|
auto existing = impl.attributeLists.insert_as(nullptr, attrs);
|
|
|
|
|
|
|
|
// If we already have it, return that value.
|
|
|
|
if (!existing.second)
|
|
|
|
return *existing.first;
|
|
|
|
|
|
|
|
// Otherwise, allocate a new AttributeListStorage, unique it and return it.
|
|
|
|
auto byteSize =
|
|
|
|
AttributeListStorage::totalSizeToAlloc<NamedAttribute>(attrs.size());
|
|
|
|
auto rawMem = impl.allocator.Allocate(byteSize, alignof(NamedAttribute));
|
|
|
|
|
|
|
|
// Placement initialize the AggregateSymbolicValue.
|
|
|
|
auto result = ::new (rawMem) AttributeListStorage(attrs.size());
|
|
|
|
std::uninitialized_copy(attrs.begin(), attrs.end(),
|
|
|
|
result->getTrailingObjects<NamedAttribute>());
|
|
|
|
return *existing.first = result;
|
|
|
|
}
|
|
|
|
|
2018-07-05 01:43:29 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// AffineMap and AffineExpr uniquing
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2018-10-10 07:39:24 +08:00
|
|
|
AffineMap AffineMap::get(unsigned dimCount, unsigned symbolCount,
|
|
|
|
ArrayRef<AffineExpr> results,
|
|
|
|
ArrayRef<AffineExpr> rangeSizes) {
|
2018-07-04 11:16:08 +08:00
|
|
|
// The number of results can't be zero.
|
|
|
|
assert(!results.empty());
|
|
|
|
|
2018-07-12 12:31:07 +08:00
|
|
|
assert(rangeSizes.empty() || results.size() == rangeSizes.size());
|
|
|
|
|
2018-10-10 01:59:27 +08:00
|
|
|
auto &impl = results[0].getContext()->getImpl();
|
2018-07-04 11:16:08 +08:00
|
|
|
|
|
|
|
// Check if we already have this affine map.
|
2018-07-12 12:31:07 +08:00
|
|
|
auto key = std::make_tuple(dimCount, symbolCount, results, rangeSizes);
|
2018-10-10 07:39:24 +08:00
|
|
|
auto existing = impl.affineMaps.insert_as(AffineMap(nullptr), key);
|
2018-07-04 11:16:08 +08:00
|
|
|
|
|
|
|
// If we already have it, return that value.
|
|
|
|
if (!existing.second)
|
|
|
|
return *existing.first;
|
|
|
|
|
|
|
|
// On the first use, we allocate them into the bump pointer.
|
2018-10-10 07:39:24 +08:00
|
|
|
auto *res = impl.allocator.Allocate<detail::AffineMapStorage>();
|
2018-07-04 11:16:08 +08:00
|
|
|
|
2018-07-13 09:04:04 +08:00
|
|
|
// Copy the results and range sizes into the bump pointer.
|
[RFC][MLIR] Use AffineExprRef in place of AffineExpr* in IR
This CL starts by replacing AffineExpr* with value-type AffineExprRef in a few
places in the IR. By a domino effect that is pretty telling of the
inconsistencies in the codebase, const is removed where it makes sense.
The rationale is that the decision was concisously made that unique'd types
have pointer semantics without const specifier. This is fine but we should be
consistent. In the end, the only logical invariant is that there should never
be such a thing as a const AffineExpr*, const AffineMap* or const IntegerSet*
in our codebase.
This CL takes a number of shortcuts to killing const with fire, in particular
forcing const AffineExprRef to return the underlying non-const
AffineExpr*. This will be removed once AffineExpr* has disappeared in
containers but for now such shortcuts allow a bit of sanity in this long quest
for cleanups.
The **only** places where const AffineExpr*, const AffineMap* or const
IntegerSet* may still appear is by transitive needs from containers,
comparison operators etc.
There is still one major thing remaining here: figure out why cast/dyn_cast
return me a const AffineXXX*, which in turn requires a bunch of ugly
const_casts. I suspect this is due to the classof
taking const AffineXXXExpr*. I wonder whether this is a side effect of 1., if
it is coming from llvm itself (I'd doubt it) or something else (clattner@?)
In light of this, the whole discussion about const makes total sense to me now
and I would systematically apply the rule that in the end, we should never
have any const XXX in our codebase for unique'd types (assuming we can remove
them all in containers and no additional constness constraint is added on us
from the outside world).
PiperOrigin-RevId: 215811554
2018-10-05 06:10:33 +08:00
|
|
|
results = impl.copyInto(results);
|
|
|
|
rangeSizes = impl.copyInto(rangeSizes);
|
2018-07-12 12:31:07 +08:00
|
|
|
|
2018-07-04 11:16:08 +08:00
|
|
|
// Initialize the memory using placement new.
|
2018-10-10 07:39:24 +08:00
|
|
|
new (res) detail::AffineMapStorage{dimCount, symbolCount,
|
|
|
|
static_cast<unsigned>(results.size()),
|
|
|
|
results, rangeSizes};
|
2018-07-04 11:16:08 +08:00
|
|
|
|
|
|
|
// Cache and return it.
|
2018-10-10 07:39:24 +08:00
|
|
|
return *existing.first = AffineMap(res);
|
2018-06-30 09:09:29 +08:00
|
|
|
}
|
|
|
|
|
2018-10-09 01:20:25 +08:00
|
|
|
/// Simplify add expression. Return nullptr if it can't be simplified.
|
2018-10-09 04:47:18 +08:00
|
|
|
static AffineExpr simplifyAdd(AffineExpr lhs, AffineExpr rhs) {
|
|
|
|
auto lhsConst = lhs.dyn_cast<AffineConstantExpr>();
|
|
|
|
auto rhsConst = rhs.dyn_cast<AffineConstantExpr>();
|
2018-10-09 01:20:25 +08:00
|
|
|
// Fold if both LHS, RHS are a constant.
|
|
|
|
if (lhsConst && rhsConst)
|
2018-10-10 01:59:27 +08:00
|
|
|
return getAffineConstantExpr(lhsConst.getValue() + rhsConst.getValue(),
|
|
|
|
lhs.getContext());
|
2018-10-09 01:20:25 +08:00
|
|
|
|
|
|
|
// Canonicalize so that only the RHS is a constant. (4 + d0 becomes d0 + 4).
|
|
|
|
// If only one of them is a symbolic expressions, make it the RHS.
|
2018-10-09 04:47:18 +08:00
|
|
|
if (lhs.isa<AffineConstantExpr>() ||
|
2018-10-10 01:59:27 +08:00
|
|
|
(lhs.isSymbolicOrConstant() && !rhs.isSymbolicOrConstant())) {
|
2018-10-09 01:20:25 +08:00
|
|
|
return rhs + lhs;
|
|
|
|
}
|
|
|
|
|
|
|
|
// At this point, if there was a constant, it would be on the right.
|
|
|
|
|
|
|
|
// Addition with a zero is a noop, return the other input.
|
|
|
|
if (rhsConst) {
|
2018-10-10 01:59:27 +08:00
|
|
|
if (rhsConst.getValue() == 0)
|
2018-10-09 01:20:25 +08:00
|
|
|
return lhs;
|
|
|
|
}
|
|
|
|
// Fold successive additions like (d0 + 2) + 3 into d0 + 5.
|
2018-10-09 04:47:18 +08:00
|
|
|
auto lBin = lhs.dyn_cast<AffineBinaryOpExpr>();
|
2018-10-10 01:59:27 +08:00
|
|
|
if (lBin && rhsConst && lBin.getKind() == AffineExprKind::Add) {
|
|
|
|
if (auto lrhs = lBin.getRHS().dyn_cast<AffineConstantExpr>())
|
|
|
|
return lBin.getLHS() + (lrhs.getValue() + rhsConst.getValue());
|
2018-10-09 01:20:25 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// When doing successive additions, bring constant to the right: turn (d0 + 2)
|
|
|
|
// + d1 into (d0 + d1) + 2.
|
2018-10-10 01:59:27 +08:00
|
|
|
if (lBin && lBin.getKind() == AffineExprKind::Add) {
|
|
|
|
if (auto lrhs = lBin.getRHS().dyn_cast<AffineConstantExpr>()) {
|
|
|
|
return lBin.getLHS() + rhs + lrhs;
|
2018-10-09 01:20:25 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Simplify a multiply expression. Return nullptr if it can't be simplified.
|
2018-10-09 04:47:18 +08:00
|
|
|
static AffineExpr simplifyMul(AffineExpr lhs, AffineExpr rhs) {
|
|
|
|
auto lhsConst = lhs.dyn_cast<AffineConstantExpr>();
|
|
|
|
auto rhsConst = rhs.dyn_cast<AffineConstantExpr>();
|
2018-10-09 01:20:25 +08:00
|
|
|
|
|
|
|
if (lhsConst && rhsConst)
|
2018-10-10 01:59:27 +08:00
|
|
|
return getAffineConstantExpr(lhsConst.getValue() * rhsConst.getValue(),
|
|
|
|
lhs.getContext());
|
2018-10-09 01:20:25 +08:00
|
|
|
|
2018-10-10 01:59:27 +08:00
|
|
|
assert(lhs.isSymbolicOrConstant() || rhs.isSymbolicOrConstant());
|
2018-10-09 01:20:25 +08:00
|
|
|
|
|
|
|
// Canonicalize the mul expression so that the constant/symbolic term is the
|
|
|
|
// RHS. If both the lhs and rhs are symbolic, swap them if the lhs is a
|
|
|
|
// constant. (Note that a constant is trivially symbolic).
|
2018-10-10 01:59:27 +08:00
|
|
|
if (!rhs.isSymbolicOrConstant() || lhs.isa<AffineConstantExpr>()) {
|
2018-10-09 01:20:25 +08:00
|
|
|
// At least one of them has to be symbolic.
|
|
|
|
return rhs * lhs;
|
|
|
|
}
|
|
|
|
|
|
|
|
// At this point, if there was a constant, it would be on the right.
|
|
|
|
|
|
|
|
// Multiplication with a one is a noop, return the other input.
|
|
|
|
if (rhsConst) {
|
2018-10-10 01:59:27 +08:00
|
|
|
if (rhsConst.getValue() == 1)
|
2018-10-09 01:20:25 +08:00
|
|
|
return lhs;
|
|
|
|
// Multiplication with zero.
|
2018-10-10 01:59:27 +08:00
|
|
|
if (rhsConst.getValue() == 0)
|
2018-10-09 01:20:25 +08:00
|
|
|
return rhsConst;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Fold successive multiplications: eg: (d0 * 2) * 3 into d0 * 6.
|
2018-10-09 04:47:18 +08:00
|
|
|
auto lBin = lhs.dyn_cast<AffineBinaryOpExpr>();
|
2018-10-10 01:59:27 +08:00
|
|
|
if (lBin && rhsConst && lBin.getKind() == AffineExprKind::Mul) {
|
|
|
|
if (auto lrhs = lBin.getRHS().dyn_cast<AffineConstantExpr>())
|
|
|
|
return lBin.getLHS() * (lrhs.getValue() * rhsConst.getValue());
|
2018-10-09 01:20:25 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// When doing successive multiplication, bring constant to the right: turn (d0
|
|
|
|
// * 2) * d1 into (d0 * d1) * 2.
|
2018-10-10 01:59:27 +08:00
|
|
|
if (lBin && lBin.getKind() == AffineExprKind::Mul) {
|
|
|
|
if (auto lrhs = lBin.getRHS().dyn_cast<AffineConstantExpr>()) {
|
|
|
|
return (lBin.getLHS() * rhs) * lrhs;
|
2018-10-09 01:20:25 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2018-10-09 04:47:18 +08:00
|
|
|
static AffineExpr simplifyFloorDiv(AffineExpr lhs, AffineExpr rhs) {
|
|
|
|
auto lhsConst = lhs.dyn_cast<AffineConstantExpr>();
|
|
|
|
auto rhsConst = rhs.dyn_cast<AffineConstantExpr>();
|
2018-10-09 01:20:25 +08:00
|
|
|
|
|
|
|
if (lhsConst && rhsConst)
|
|
|
|
return getAffineConstantExpr(
|
2018-10-10 01:59:27 +08:00
|
|
|
floorDiv(lhsConst.getValue(), rhsConst.getValue()), lhs.getContext());
|
2018-10-09 01:20:25 +08:00
|
|
|
|
|
|
|
// Fold floordiv of a multiply with a constant that is a multiple of the
|
|
|
|
// divisor. Eg: (i * 128) floordiv 64 = i * 2.
|
|
|
|
if (rhsConst) {
|
2018-10-10 01:59:27 +08:00
|
|
|
if (rhsConst.getValue() == 1)
|
2018-10-09 01:20:25 +08:00
|
|
|
return lhs;
|
|
|
|
|
2018-10-09 04:47:18 +08:00
|
|
|
auto lBin = lhs.dyn_cast<AffineBinaryOpExpr>();
|
2018-10-10 01:59:27 +08:00
|
|
|
if (lBin && lBin.getKind() == AffineExprKind::Mul) {
|
|
|
|
if (auto lrhs = lBin.getRHS().dyn_cast<AffineConstantExpr>()) {
|
2018-10-09 01:20:25 +08:00
|
|
|
// rhsConst is known to be positive if a constant.
|
2018-10-10 01:59:27 +08:00
|
|
|
if (lrhs.getValue() % rhsConst.getValue() == 0)
|
|
|
|
return lBin.getLHS() * (lrhs.getValue() / rhsConst.getValue());
|
2018-10-09 01:20:25 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2018-10-09 04:47:18 +08:00
|
|
|
static AffineExpr simplifyCeilDiv(AffineExpr lhs, AffineExpr rhs) {
|
|
|
|
auto lhsConst = lhs.dyn_cast<AffineConstantExpr>();
|
|
|
|
auto rhsConst = rhs.dyn_cast<AffineConstantExpr>();
|
2018-10-09 01:20:25 +08:00
|
|
|
|
|
|
|
if (lhsConst && rhsConst)
|
|
|
|
return getAffineConstantExpr(
|
2018-10-10 01:59:27 +08:00
|
|
|
ceilDiv(lhsConst.getValue(), rhsConst.getValue()), lhs.getContext());
|
2018-10-09 01:20:25 +08:00
|
|
|
|
|
|
|
// Fold ceildiv of a multiply with a constant that is a multiple of the
|
|
|
|
// divisor. Eg: (i * 128) ceildiv 64 = i * 2.
|
|
|
|
if (rhsConst) {
|
2018-10-10 01:59:27 +08:00
|
|
|
if (rhsConst.getValue() == 1)
|
2018-10-09 01:20:25 +08:00
|
|
|
return lhs;
|
|
|
|
|
2018-10-09 04:47:18 +08:00
|
|
|
auto lBin = lhs.dyn_cast<AffineBinaryOpExpr>();
|
2018-10-10 01:59:27 +08:00
|
|
|
if (lBin && lBin.getKind() == AffineExprKind::Mul) {
|
|
|
|
if (auto lrhs = lBin.getRHS().dyn_cast<AffineConstantExpr>()) {
|
2018-10-09 01:20:25 +08:00
|
|
|
// rhsConst is known to be positive if a constant.
|
2018-10-10 01:59:27 +08:00
|
|
|
if (lrhs.getValue() % rhsConst.getValue() == 0)
|
|
|
|
return lBin.getLHS() * (lrhs.getValue() / rhsConst.getValue());
|
2018-10-09 01:20:25 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2018-10-09 04:47:18 +08:00
|
|
|
static AffineExpr simplifyMod(AffineExpr lhs, AffineExpr rhs) {
|
|
|
|
auto lhsConst = lhs.dyn_cast<AffineConstantExpr>();
|
|
|
|
auto rhsConst = rhs.dyn_cast<AffineConstantExpr>();
|
2018-10-09 01:20:25 +08:00
|
|
|
|
|
|
|
if (lhsConst && rhsConst)
|
2018-10-10 01:59:27 +08:00
|
|
|
return getAffineConstantExpr(mod(lhsConst.getValue(), rhsConst.getValue()),
|
|
|
|
lhs.getContext());
|
2018-10-09 01:20:25 +08:00
|
|
|
|
|
|
|
// Fold modulo of an expression that is known to be a multiple of a constant
|
|
|
|
// to zero if that constant is a multiple of the modulo factor. Eg: (i * 128)
|
|
|
|
// mod 64 is folded to 0, and less trivially, (i*(j*4*(k*32))) mod 128 = 0.
|
|
|
|
if (rhsConst) {
|
|
|
|
// rhsConst is known to be positive if a constant.
|
2018-10-10 01:59:27 +08:00
|
|
|
if (lhs.getLargestKnownDivisor() % rhsConst.getValue() == 0)
|
|
|
|
return getAffineConstantExpr(0, lhs.getContext());
|
2018-10-09 01:20:25 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return nullptr;
|
|
|
|
// TODO(bondhugula): In general, this can be simplified more by using the GCD
|
|
|
|
// test, or in general using quantifier elimination (add two new variables q
|
|
|
|
// and r, and eliminate all variables from the linear system other than r. All
|
|
|
|
// of this can be done through mlir/Analysis/'s FlatAffineConstraints.
|
|
|
|
}
|
|
|
|
|
2018-07-12 12:19:31 +08:00
|
|
|
/// Return a binary affine op expression with the specified op type and
|
|
|
|
/// operands: if it doesn't exist, create it and store it; if it is already
|
|
|
|
/// present, return from the list. The stored expressions are unique: they are
|
|
|
|
/// constructed and stored in a simplified/canonicalized form. The result after
|
|
|
|
/// simplification could be any form of affine expression.
|
2018-10-10 01:59:27 +08:00
|
|
|
AffineExpr AffineBinaryOpExprStorage::get(AffineExprKind kind, AffineExpr lhs,
|
|
|
|
AffineExpr rhs) {
|
|
|
|
auto &impl = lhs.getContext()->getImpl();
|
2018-07-04 11:16:08 +08:00
|
|
|
|
2018-07-26 15:19:21 +08:00
|
|
|
// Check if we already have this affine expression, and return it if we do.
|
[RFC][MLIR] Use AffineExprRef in place of AffineExpr* in IR
This CL starts by replacing AffineExpr* with value-type AffineExprRef in a few
places in the IR. By a domino effect that is pretty telling of the
inconsistencies in the codebase, const is removed where it makes sense.
The rationale is that the decision was concisously made that unique'd types
have pointer semantics without const specifier. This is fine but we should be
consistent. In the end, the only logical invariant is that there should never
be such a thing as a const AffineExpr*, const AffineMap* or const IntegerSet*
in our codebase.
This CL takes a number of shortcuts to killing const with fire, in particular
forcing const AffineExprRef to return the underlying non-const
AffineExpr*. This will be removed once AffineExpr* has disappeared in
containers but for now such shortcuts allow a bit of sanity in this long quest
for cleanups.
The **only** places where const AffineExpr*, const AffineMap* or const
IntegerSet* may still appear is by transitive needs from containers,
comparison operators etc.
There is still one major thing remaining here: figure out why cast/dyn_cast
return me a const AffineXXX*, which in turn requires a bunch of ugly
const_casts. I suspect this is due to the classof
taking const AffineXXXExpr*. I wonder whether this is a side effect of 1., if
it is coming from llvm itself (I'd doubt it) or something else (clattner@?)
In light of this, the whole discussion about const makes total sense to me now
and I would systematically apply the rule that in the end, we should never
have any const XXX in our codebase for unique'd types (assuming we can remove
them all in containers and no additional constness constraint is added on us
from the outside world).
PiperOrigin-RevId: 215811554
2018-10-05 06:10:33 +08:00
|
|
|
auto keyValue = std::make_tuple((unsigned)kind, lhs, rhs);
|
2018-07-26 15:19:21 +08:00
|
|
|
auto cached = impl.affineExprs.find(keyValue);
|
|
|
|
if (cached != impl.affineExprs.end())
|
2018-10-10 01:59:27 +08:00
|
|
|
return cached->second;
|
2018-07-10 00:00:25 +08:00
|
|
|
|
2018-07-12 12:19:31 +08:00
|
|
|
// Simplify the expression if possible.
|
2018-10-09 04:47:18 +08:00
|
|
|
AffineExpr simplified;
|
2018-07-12 12:19:31 +08:00
|
|
|
switch (kind) {
|
2018-10-09 01:20:25 +08:00
|
|
|
case AffineExprKind::Add:
|
2018-10-09 04:47:18 +08:00
|
|
|
simplified = simplifyAdd(lhs, rhs);
|
2018-07-12 12:19:31 +08:00
|
|
|
break;
|
2018-10-09 01:20:25 +08:00
|
|
|
case AffineExprKind::Mul:
|
2018-10-09 04:47:18 +08:00
|
|
|
simplified = simplifyMul(lhs, rhs);
|
2018-07-12 12:19:31 +08:00
|
|
|
break;
|
2018-10-09 01:20:25 +08:00
|
|
|
case AffineExprKind::FloorDiv:
|
2018-10-09 04:47:18 +08:00
|
|
|
simplified = simplifyFloorDiv(lhs, rhs);
|
2018-07-12 12:19:31 +08:00
|
|
|
break;
|
2018-10-09 01:20:25 +08:00
|
|
|
case AffineExprKind::CeilDiv:
|
2018-10-09 04:47:18 +08:00
|
|
|
simplified = simplifyCeilDiv(lhs, rhs);
|
2018-07-12 12:19:31 +08:00
|
|
|
break;
|
2018-10-09 01:20:25 +08:00
|
|
|
case AffineExprKind::Mod:
|
2018-10-09 04:47:18 +08:00
|
|
|
simplified = simplifyMod(lhs, rhs);
|
2018-07-12 12:19:31 +08:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
llvm_unreachable("unexpected binary affine expr");
|
2018-07-04 11:16:08 +08:00
|
|
|
}
|
2018-06-30 09:09:29 +08:00
|
|
|
|
2018-07-26 15:19:21 +08:00
|
|
|
// The simplified one would have already been cached; just return it.
|
2018-07-12 12:19:31 +08:00
|
|
|
if (simplified)
|
2018-10-10 01:59:27 +08:00
|
|
|
return simplified;
|
2018-07-10 00:00:25 +08:00
|
|
|
|
2018-07-26 15:19:21 +08:00
|
|
|
// An expression with these operands will already be in the
|
|
|
|
// simplified/canonical form. Create and store it.
|
2018-10-10 01:59:27 +08:00
|
|
|
auto *result = impl.allocator.Allocate<AffineBinaryOpExprStorage>();
|
2018-07-12 12:19:31 +08:00
|
|
|
// Initialize the memory using placement new.
|
2018-10-10 01:59:27 +08:00
|
|
|
new (result) AffineBinaryOpExprStorage{{kind, lhs.getContext()}, lhs, rhs};
|
2018-07-26 15:19:21 +08:00
|
|
|
bool inserted = impl.affineExprs.insert({keyValue, result}).second;
|
|
|
|
assert(inserted && "the expression shouldn't already exist in the map");
|
|
|
|
(void)inserted;
|
|
|
|
return result;
|
2018-07-04 11:16:08 +08:00
|
|
|
}
|
|
|
|
|
2018-10-09 04:47:18 +08:00
|
|
|
AffineExpr mlir::getAffineDimExpr(unsigned position, MLIRContext *context) {
|
2018-07-25 13:34:09 +08:00
|
|
|
auto &impl = context->getImpl();
|
|
|
|
|
|
|
|
// Check if we need to resize.
|
|
|
|
if (position >= impl.dimExprs.size())
|
|
|
|
impl.dimExprs.resize(position + 1, nullptr);
|
|
|
|
|
|
|
|
auto *&result = impl.dimExprs[position];
|
|
|
|
if (result)
|
|
|
|
return result;
|
|
|
|
|
2018-10-10 01:59:27 +08:00
|
|
|
result = impl.allocator.Allocate<AffineDimExprStorage>();
|
2018-07-25 13:34:09 +08:00
|
|
|
// Initialize the memory using placement new.
|
2018-10-10 01:59:27 +08:00
|
|
|
new (result) AffineDimExprStorage{{AffineExprKind::DimId, context}, position};
|
2018-07-25 13:34:09 +08:00
|
|
|
return result;
|
2018-06-30 09:09:29 +08:00
|
|
|
}
|
|
|
|
|
2018-10-09 04:47:18 +08:00
|
|
|
AffineExpr mlir::getAffineSymbolExpr(unsigned position, MLIRContext *context) {
|
2018-07-25 13:34:09 +08:00
|
|
|
auto &impl = context->getImpl();
|
|
|
|
|
|
|
|
// Check if we need to resize.
|
|
|
|
if (position >= impl.symbolExprs.size())
|
|
|
|
impl.symbolExprs.resize(position + 1, nullptr);
|
|
|
|
|
|
|
|
auto *&result = impl.symbolExprs[position];
|
|
|
|
if (result)
|
|
|
|
return result;
|
|
|
|
|
2018-10-10 01:59:27 +08:00
|
|
|
result = impl.allocator.Allocate<AffineSymbolExprStorage>();
|
2018-07-25 13:34:09 +08:00
|
|
|
// Initialize the memory using placement new.
|
2018-10-10 01:59:27 +08:00
|
|
|
new (result)
|
|
|
|
AffineSymbolExprStorage{{AffineExprKind::SymbolId, context}, position};
|
2018-07-25 13:34:09 +08:00
|
|
|
return result;
|
2018-06-30 09:09:29 +08:00
|
|
|
}
|
|
|
|
|
2018-10-09 04:47:18 +08:00
|
|
|
AffineExpr mlir::getAffineConstantExpr(int64_t constant, MLIRContext *context) {
|
2018-07-25 13:34:09 +08:00
|
|
|
auto &impl = context->getImpl();
|
|
|
|
auto *&result = impl.constExprs[constant];
|
|
|
|
|
|
|
|
if (result)
|
|
|
|
return result;
|
|
|
|
|
2018-10-10 01:59:27 +08:00
|
|
|
result = impl.allocator.Allocate<AffineConstantExprStorage>();
|
2018-07-25 13:34:09 +08:00
|
|
|
// Initialize the memory using placement new.
|
2018-10-10 01:59:27 +08:00
|
|
|
new (result)
|
|
|
|
AffineConstantExprStorage{{AffineExprKind::Constant, context}, constant};
|
2018-07-25 13:34:09 +08:00
|
|
|
return result;
|
2018-06-30 09:09:29 +08:00
|
|
|
}
|
2018-08-08 05:24:38 +08:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Integer Sets: these are allocated into the bump pointer, and are immutable.
|
|
|
|
// But they aren't uniqued like AffineMap's; there isn't an advantage to.
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
IntegerSet *IntegerSet::get(unsigned dimCount, unsigned symbolCount,
|
2018-10-09 04:47:18 +08:00
|
|
|
ArrayRef<AffineExpr> constraints,
|
2018-08-08 05:24:38 +08:00
|
|
|
ArrayRef<bool> eqFlags, MLIRContext *context) {
|
|
|
|
assert(eqFlags.size() == constraints.size());
|
|
|
|
|
|
|
|
auto &impl = context->getImpl();
|
|
|
|
|
|
|
|
// Allocate them into the bump pointer.
|
|
|
|
auto *res = impl.allocator.Allocate<IntegerSet>();
|
|
|
|
|
|
|
|
// Copy the equalities and inequalities into the bump pointer.
|
2018-10-09 04:47:18 +08:00
|
|
|
constraints = impl.copyInto(ArrayRef<AffineExpr>(constraints));
|
2018-08-08 05:24:38 +08:00
|
|
|
eqFlags = impl.copyInto(ArrayRef<bool>(eqFlags));
|
|
|
|
|
|
|
|
// Initialize the memory using placement new.
|
|
|
|
return new (res) IntegerSet(dimCount, symbolCount, constraints.size(),
|
[RFC][MLIR] Use AffineExprRef in place of AffineExpr* in IR
This CL starts by replacing AffineExpr* with value-type AffineExprRef in a few
places in the IR. By a domino effect that is pretty telling of the
inconsistencies in the codebase, const is removed where it makes sense.
The rationale is that the decision was concisously made that unique'd types
have pointer semantics without const specifier. This is fine but we should be
consistent. In the end, the only logical invariant is that there should never
be such a thing as a const AffineExpr*, const AffineMap* or const IntegerSet*
in our codebase.
This CL takes a number of shortcuts to killing const with fire, in particular
forcing const AffineExprRef to return the underlying non-const
AffineExpr*. This will be removed once AffineExpr* has disappeared in
containers but for now such shortcuts allow a bit of sanity in this long quest
for cleanups.
The **only** places where const AffineExpr*, const AffineMap* or const
IntegerSet* may still appear is by transitive needs from containers,
comparison operators etc.
There is still one major thing remaining here: figure out why cast/dyn_cast
return me a const AffineXXX*, which in turn requires a bunch of ugly
const_casts. I suspect this is due to the classof
taking const AffineXXXExpr*. I wonder whether this is a side effect of 1., if
it is coming from llvm itself (I'd doubt it) or something else (clattner@?)
In light of this, the whole discussion about const makes total sense to me now
and I would systematically apply the rule that in the end, we should never
have any const XXX in our codebase for unique'd types (assuming we can remove
them all in containers and no additional constness constraint is added on us
from the outside world).
PiperOrigin-RevId: 215811554
2018-10-05 06:10:33 +08:00
|
|
|
constraints, eqFlags);
|
2018-08-08 05:24:38 +08:00
|
|
|
}
|