/// expected to fill in order to build the operation.
static void buildConstantOp(mlir::Builder *builder,
mlir::OperationState &result, double value) {
- auto dataType = builder->getTensorType({}, builder->getF64Type());
+ auto dataType = RankedTensorType::get({}, builder->getF64Type());
auto dataAttribute = DenseElementsAttr::get(dataType, value);
ConstantOp::build(builder, result, dataType, dataAttribute);
}
static void buildAddOp(mlir::Builder *builder, mlir::OperationState &result,
mlir::Value *lhs, mlir::Value *rhs) {
- result.addTypes(builder->getTensorType(builder->getF64Type()));
+ result.addTypes(UnrankedTensorType::get(builder->getF64Type()));
result.addOperands({lhs, rhs});
}
mlir::OperationState &result, StringRef callee,
ArrayRef<mlir::Value *> arguments) {
// Generic call always returns an unranked Tensor initially.
- result.addTypes(builder->getTensorType(builder->getF64Type()));
+ result.addTypes(UnrankedTensorType::get(builder->getF64Type()));
result.addOperands(arguments);
result.addAttribute("callee", builder->getSymbolRefAttr(callee));
}
static void buildMulOp(mlir::Builder *builder, mlir::OperationState &result,
mlir::Value *lhs, mlir::Value *rhs) {
- result.addTypes(builder->getTensorType(builder->getF64Type()));
+ result.addTypes(UnrankedTensorType::get(builder->getF64Type()));
result.addOperands({lhs, rhs});
}
static void buildTransposeOp(mlir::Builder *builder,
mlir::OperationState &result, mlir::Value *value) {
- result.addTypes(builder->getTensorType(builder->getF64Type()));
+ result.addTypes(UnrankedTensorType::get(builder->getF64Type()));
result.addOperands(value);
}
// The type of this attribute is tensor of 64-bit floating-point with the
// shape of the literal.
mlir::Type elementType = builder.getF64Type();
- auto dataType = builder.getTensorType(lit.getDims(), elementType);
+ auto dataType = mlir::RankedTensorType::get(lit.getDims(), elementType);
// This is the actual attribute that holds the list of values for this
// tensor literal.
mlir::Type getType(ArrayRef<int64_t> shape) {
// If the shape is empty, then this type is unranked.
if (shape.empty())
- return builder.getTensorType(builder.getF64Type());
+ return mlir::UnrankedTensorType::get(builder.getF64Type());
// Otherwise, we use the given shape.
- return builder.getTensorType(shape, builder.getF64Type());
+ return mlir::RankedTensorType::get(shape, builder.getF64Type());
}
/// Build an MLIR type from a Toy AST variable type (forward to the generic
/// expected to fill in order to build the operation.
static void buildConstantOp(mlir::Builder *builder, mlir::OperationState &state,
double value) {
- auto dataType = builder->getTensorType({}, builder->getF64Type());
+ auto dataType = RankedTensorType::get({}, builder->getF64Type());
auto dataAttribute = DenseElementsAttr::get(dataType, value);
ConstantOp::build(builder, state, dataType, dataAttribute);
}
static void buildAddOp(mlir::Builder *builder, mlir::OperationState &state,
mlir::Value *lhs, mlir::Value *rhs) {
- state.addTypes(builder->getTensorType(builder->getF64Type()));
+ state.addTypes(UnrankedTensorType::get(builder->getF64Type()));
state.addOperands({lhs, rhs});
}
mlir::OperationState &state, StringRef callee,
ArrayRef<mlir::Value *> arguments) {
// Generic call always returns an unranked Tensor initially.
- state.addTypes(builder->getTensorType(builder->getF64Type()));
+ state.addTypes(UnrankedTensorType::get(builder->getF64Type()));
state.addOperands(arguments);
state.addAttribute("callee", builder->getSymbolRefAttr(callee));
}
static void buildMulOp(mlir::Builder *builder, mlir::OperationState &state,
mlir::Value *lhs, mlir::Value *rhs) {
- state.addTypes(builder->getTensorType(builder->getF64Type()));
+ state.addTypes(UnrankedTensorType::get(builder->getF64Type()));
state.addOperands({lhs, rhs});
}
static void buildTransposeOp(mlir::Builder *builder,
mlir::OperationState &state, mlir::Value *value) {
- state.addTypes(builder->getTensorType(builder->getF64Type()));
+ state.addTypes(UnrankedTensorType::get(builder->getF64Type()));
state.addOperands(value);
}
// The type of this attribute is tensor of 64-bit floating-point with the
// shape of the literal.
mlir::Type elementType = builder.getF64Type();
- auto dataType = builder.getTensorType(lit.getDims(), elementType);
+ auto dataType = mlir::RankedTensorType::get(lit.getDims(), elementType);
// This is the actual attribute that holds the list of values for this
// tensor literal.
mlir::Type getType(ArrayRef<int64_t> shape) {
// If the shape is empty, then this type is unranked.
if (shape.empty())
- return builder.getTensorType(builder.getF64Type());
+ return mlir::UnrankedTensorType::get(builder.getF64Type());
// Otherwise, we use the given shape.
- return builder.getTensorType(shape, builder.getF64Type());
+ return mlir::RankedTensorType::get(shape, builder.getF64Type());
}
/// Build an MLIR type from a Toy AST variable type (forward to the generic
/// expected to fill in order to build the operation.
static void buildConstantOp(mlir::Builder *builder, mlir::OperationState &state,
double value) {
- auto dataType = builder->getTensorType({}, builder->getF64Type());
+ auto dataType = RankedTensorType::get({}, builder->getF64Type());
auto dataAttribute = DenseElementsAttr::get(dataType, value);
ConstantOp::build(builder, state, dataType, dataAttribute);
}
static void buildAddOp(mlir::Builder *builder, mlir::OperationState &state,
mlir::Value *lhs, mlir::Value *rhs) {
- state.addTypes(builder->getTensorType(builder->getF64Type()));
+ state.addTypes(UnrankedTensorType::get(builder->getF64Type()));
state.addOperands({lhs, rhs});
}
mlir::OperationState &state, StringRef callee,
ArrayRef<mlir::Value *> arguments) {
// Generic call always returns an unranked Tensor initially.
- state.addTypes(builder->getTensorType(builder->getF64Type()));
+ state.addTypes(UnrankedTensorType::get(builder->getF64Type()));
state.addOperands(arguments);
state.addAttribute("callee", builder->getSymbolRefAttr(callee));
}
static void buildMulOp(mlir::Builder *builder, mlir::OperationState &state,
mlir::Value *lhs, mlir::Value *rhs) {
- state.addTypes(builder->getTensorType(builder->getF64Type()));
+ state.addTypes(UnrankedTensorType::get(builder->getF64Type()));
state.addOperands({lhs, rhs});
}
static void buildTransposeOp(mlir::Builder *builder,
mlir::OperationState &state, mlir::Value *value) {
- state.addTypes(builder->getTensorType(builder->getF64Type()));
+ state.addTypes(UnrankedTensorType::get(builder->getF64Type()));
state.addOperands(value);
}
// The type of this attribute is tensor of 64-bit floating-point with the
// shape of the literal.
mlir::Type elementType = builder.getF64Type();
- auto dataType = builder.getTensorType(lit.getDims(), elementType);
+ auto dataType = mlir::RankedTensorType::get(lit.getDims(), elementType);
// This is the actual attribute that holds the list of values for this
// tensor literal.
mlir::Type getType(ArrayRef<int64_t> shape) {
// If the shape is empty, then this type is unranked.
if (shape.empty())
- return builder.getTensorType(builder.getF64Type());
+ return mlir::UnrankedTensorType::get(builder.getF64Type());
// Otherwise, we use the given shape.
- return builder.getTensorType(shape, builder.getF64Type());
+ return mlir::RankedTensorType::get(shape, builder.getF64Type());
}
/// Build an MLIR type from a Toy AST variable type (forward to the generic
/// expected to fill in order to build the operation.
static void buildConstantOp(mlir::Builder *builder, mlir::OperationState &state,
double value) {
- auto dataType = builder->getTensorType({}, builder->getF64Type());
+ auto dataType = RankedTensorType::get({}, builder->getF64Type());
auto dataAttribute = DenseElementsAttr::get(dataType, value);
ConstantOp::build(builder, state, dataType, dataAttribute);
}
static void buildAddOp(mlir::Builder *builder, mlir::OperationState &state,
mlir::Value *lhs, mlir::Value *rhs) {
- state.addTypes(builder->getTensorType(builder->getF64Type()));
+ state.addTypes(UnrankedTensorType::get(builder->getF64Type()));
state.addOperands({lhs, rhs});
}
mlir::OperationState &state, StringRef callee,
ArrayRef<mlir::Value *> arguments) {
// Generic call always returns an unranked Tensor initially.
- state.addTypes(builder->getTensorType(builder->getF64Type()));
+ state.addTypes(UnrankedTensorType::get(builder->getF64Type()));
state.addOperands(arguments);
state.addAttribute("callee", builder->getSymbolRefAttr(callee));
}
static void buildMulOp(mlir::Builder *builder, mlir::OperationState &state,
mlir::Value *lhs, mlir::Value *rhs) {
- state.addTypes(builder->getTensorType(builder->getF64Type()));
+ state.addTypes(UnrankedTensorType::get(builder->getF64Type()));
state.addOperands({lhs, rhs});
}
static void buildTransposeOp(mlir::Builder *builder,
mlir::OperationState &state, mlir::Value *value) {
- state.addTypes(builder->getTensorType(builder->getF64Type()));
+ state.addTypes(UnrankedTensorType::get(builder->getF64Type()));
state.addOperands(value);
}
// The type of this attribute is tensor of 64-bit floating-point with the
// shape of the literal.
mlir::Type elementType = builder.getF64Type();
- auto dataType = builder.getTensorType(lit.getDims(), elementType);
+ auto dataType = mlir::RankedTensorType::get(lit.getDims(), elementType);
// This is the actual attribute that holds the list of values for this
// tensor literal.
mlir::Type getType(ArrayRef<int64_t> shape) {
// If the shape is empty, then this type is unranked.
if (shape.empty())
- return builder.getTensorType(builder.getF64Type());
+ return mlir::UnrankedTensorType::get(builder.getF64Type());
// Otherwise, we use the given shape.
- return builder.getTensorType(shape, builder.getF64Type());
+ return mlir::RankedTensorType::get(shape, builder.getF64Type());
}
/// Build an MLIR type from a Toy AST variable type (forward to the generic
/// expected to fill in order to build the operation.
static void buildConstantOp(mlir::Builder *builder, mlir::OperationState &state,
double value) {
- auto dataType = builder->getTensorType({}, builder->getF64Type());
+ auto dataType = RankedTensorType::get({}, builder->getF64Type());
auto dataAttribute = DenseElementsAttr::get(dataType, value);
ConstantOp::build(builder, state, dataType, dataAttribute);
}
static void buildAddOp(mlir::Builder *builder, mlir::OperationState &state,
mlir::Value *lhs, mlir::Value *rhs) {
- state.addTypes(builder->getTensorType(builder->getF64Type()));
+ state.addTypes(UnrankedTensorType::get(builder->getF64Type()));
state.addOperands({lhs, rhs});
}
mlir::OperationState &state, StringRef callee,
ArrayRef<mlir::Value *> arguments) {
// Generic call always returns an unranked Tensor initially.
- state.addTypes(builder->getTensorType(builder->getF64Type()));
+ state.addTypes(UnrankedTensorType::get(builder->getF64Type()));
state.addOperands(arguments);
state.addAttribute("callee", builder->getSymbolRefAttr(callee));
}
static void buildMulOp(mlir::Builder *builder, mlir::OperationState &state,
mlir::Value *lhs, mlir::Value *rhs) {
- state.addTypes(builder->getTensorType(builder->getF64Type()));
+ state.addTypes(UnrankedTensorType::get(builder->getF64Type()));
state.addOperands({lhs, rhs});
}
static void buildTransposeOp(mlir::Builder *builder,
mlir::OperationState &state, mlir::Value *value) {
- state.addTypes(builder->getTensorType(builder->getF64Type()));
+ state.addTypes(UnrankedTensorType::get(builder->getF64Type()));
state.addOperands(value);
}
// The type of this attribute is tensor of 64-bit floating-point with the
// shape of the literal.
mlir::Type elementType = builder.getF64Type();
- auto dataType = builder.getTensorType(lit.getDims(), elementType);
+ auto dataType = mlir::RankedTensorType::get(lit.getDims(), elementType);
// This is the actual attribute that holds the list of values for this
// tensor literal.
mlir::Type getType(ArrayRef<int64_t> shape) {
// If the shape is empty, then this type is unranked.
if (shape.empty())
- return builder.getTensorType(builder.getF64Type());
+ return mlir::UnrankedTensorType::get(builder.getF64Type());
// Otherwise, we use the given shape.
- return builder.getTensorType(shape, builder.getF64Type());
+ return mlir::RankedTensorType::get(shape, builder.getF64Type());
}
/// Build an MLIR type from a Toy AST variable type (forward to the generic
case spirv::BuiltIn::LocalInvocationId:
case spirv::BuiltIn::GlobalInvocationId: {
auto ptrType = spirv::PointerType::get(
- builder.getVectorType({3}, builder.getIntegerType(32)),
+ VectorType::get({3}, builder.getIntegerType(32)),
spirv::StorageClass::Input);
newVarOp = builder.create<spirv::GlobalVariableOp>(
- loc, builder.getTypeAttr(ptrType), builder.getStringAttr(name),
- nullptr);
+ loc, TypeAttr::get(ptrType), builder.getStringAttr(name), nullptr);
newVarOp.setAttr(
convertToSnakeCase(stringifyDecoration(spirv::Decoration::BuiltIn)),
builder.getStringAttr(stringifyBuiltIn(builtin)));
CPred<"$_self.isa<AffineMapAttr>()">, "AffineMap attribute"> {
let storageType = [{ AffineMapAttr }];
let returnType = [{ AffineMap }];
- let constBuilderCall = "$_builder.getAffineMapAttr($0)";
+ let constBuilderCall = "AffineMapAttr::get($0)";
}
def AffineMapArrayAttr : TypedArrayAttrBase<AffineMapAttr,
let builders = [OpBuilder<
"Builder *builder, OperationState &result, Value *memref", [{
auto memrefType = memref->getType().cast<MemRefType>();
- auto resultType = builder->getTensorType(memrefType.getShape(),
- memrefType.getElementType());
+ auto resultType = RankedTensorType::get(memrefType.getShape(),
+ memrefType.getElementType());
result.addOperands(memref);
result.addTypes(resultType);
}]>];
IntegerType getI1Type();
IntegerType getIntegerType(unsigned width);
FunctionType getFunctionType(ArrayRef<Type> inputs, ArrayRef<Type> results);
- MemRefType getMemRefType(ArrayRef<int64_t> shape, Type elementType,
- ArrayRef<AffineMap> affineMapComposition = {},
- unsigned memorySpace = 0);
- VectorType getVectorType(ArrayRef<int64_t> shape, Type elementType);
- RankedTensorType getTensorType(ArrayRef<int64_t> shape, Type elementType);
- UnrankedTensorType getTensorType(Type elementType);
TupleType getTupleType(ArrayRef<Type> elementTypes);
NoneType getNoneType();
FloatAttr getFloatAttr(Type type, double value);
FloatAttr getFloatAttr(Type type, const APFloat &value);
StringAttr getStringAttr(StringRef bytes);
- StringAttr getStringAttr(StringRef bytes, Type type);
ArrayAttr getArrayAttr(ArrayRef<Attribute> value);
- AffineMapAttr getAffineMapAttr(AffineMap map);
- IntegerSetAttr getIntegerSetAttr(IntegerSet set);
- TypeAttr getTypeAttr(Type type);
SymbolRefAttr getSymbolRefAttr(Operation *value);
SymbolRefAttr getSymbolRefAttr(StringRef value);
- ElementsAttr getDenseElementsAttr(ShapedType type,
- ArrayRef<Attribute> values);
- ElementsAttr getDenseIntElementsAttr(ShapedType type,
- ArrayRef<int64_t> values);
- ElementsAttr getSparseElementsAttr(ShapedType type,
- DenseIntElementsAttr indices,
- DenseElementsAttr values);
- ElementsAttr getOpaqueElementsAttr(Dialect *dialect, ShapedType type,
- StringRef bytes);
+
// Returns a 0-valued attribute of the given `type`. This function only
// supports boolean, integer, and 16-/32-/64-bit float types, and vector or
// ranked tensor of them. Returns null attribute otherwise.
AffineExpr getAffineSymbolExpr(unsigned position);
AffineExpr getAffineConstantExpr(int64_t constant);
- AffineMap getAffineMap(unsigned dimCount, unsigned symbolCount,
- ArrayRef<AffineExpr> results);
-
// Special cases of affine maps and integer sets
/// Returns a zero result affine map with no dimensions or symbols: () -> ().
AffineMap getEmptyAffineMap();
/// returns: (d0, d1)[s0] -> (d0 + 2, d1 + s0 + 2)
AffineMap getShiftedAffineMap(AffineMap map, int64_t shift);
- // Integer set.
- IntegerSet getIntegerSet(unsigned dimCount, unsigned symbolCount,
- ArrayRef<AffineExpr> constraints,
- ArrayRef<bool> isEq);
- // TODO: Helpers for affine map/exprs, etc.
protected:
MLIRContext *context;
};
// Note that this is only constructing scalar elements attribute.
let constBuilderCall = "DenseElementsAttr::get("
- "$_builder.getTensorType({}, $_builder.getIntegerType(" # width # ")), "
+ "RankedTensorType::get({}, $_builder.getIntegerType(" # width # ")), "
"llvm::makeArrayRef($0)).cast<DenseIntElementsAttr>()";
let convertFromStorage = "$_self";
}
// Note that this is only constructing scalar elements attribute.
let constBuilderCall = "DenseElementsAttr::get("
- "$_builder.getTensorType({}, $_builder.getF" # width # "Type()),"
+ "RankedTensorType::get({}, $_builder.getF" # width # "Type()),"
"llvm::makeArrayRef($0))";
let convertFromStorage = "$_self";
}
let returnType = [{ DenseFPElementsAttr }];
let constBuilderCall = "DenseElementsAttr::get("
- "$_builder.getTensorType({" # StrJoinInt<dims>.result #
+ "RankedTensorType::get({" # StrJoinInt<dims>.result #
"}, $_builder.getF" # width # "Type()), "
"llvm::makeArrayRef($0)).cast<DenseFPElementsAttr>()";
let convertFromStorage = "$_self";
SmallVector<AffineExpr, 4> lbSplatExpr(ubValueMap.getNumResults(),
lbMap.getResult(0));
auto lbMapSplat =
- b.getAffineMap(lbMap.getNumDims(), lbMap.getNumSymbols(), lbSplatExpr);
+ AffineMap::get(lbMap.getNumDims(), lbMap.getNumSymbols(), lbSplatExpr);
AffineValueMap lbSplatValueMap(lbMapSplat, lbOperands);
AffineValueMap tripCountValueMap;
funcOp.getName().str() + "_arg_" + std::to_string(origArgNum);
var = rewriter.create<spirv::GlobalVariableOp>(
funcOp.getLoc(),
- rewriter.getTypeAttr(getGlobalVarTypeForEntryFnArg(origArg->getType())),
+ TypeAttr::get(getGlobalVarTypeForEntryFnArg(origArg->getType())),
rewriter.getStringAttr(varName), nullptr);
var.setAttr(
spirv::SPIRVDialect::getAttributeName(spirv::Decoration::DescriptorSet),
AffineMap map, ArrayRef<Value *> operands) {
result.addOperands(operands);
result.types.append(map.getNumResults(), builder->getIndexType());
- result.addAttribute("map", builder->getAffineMapAttr(map));
+ result.addAttribute("map", AffineMapAttr::get(map));
}
ParseResult AffineApplyOp::parse(OpAsmParser &parser, OperationState &result) {
ArrayRef<Value *> tagIndices, Value *numElements,
Value *stride, Value *elementsPerStride) {
result.addOperands(srcMemRef);
- result.addAttribute(getSrcMapAttrName(), builder->getAffineMapAttr(srcMap));
+ result.addAttribute(getSrcMapAttrName(), AffineMapAttr::get(srcMap));
result.addOperands(srcIndices);
result.addOperands(destMemRef);
- result.addAttribute(getDstMapAttrName(), builder->getAffineMapAttr(dstMap));
+ result.addAttribute(getDstMapAttrName(), AffineMapAttr::get(dstMap));
result.addOperands(destIndices);
result.addOperands(tagMemRef);
- result.addAttribute(getTagMapAttrName(), builder->getAffineMapAttr(tagMap));
+ result.addAttribute(getTagMapAttrName(), AffineMapAttr::get(tagMap));
result.addOperands(tagIndices);
result.addOperands(numElements);
if (stride) {
Value *tagMemRef, AffineMap tagMap,
ArrayRef<Value *> tagIndices, Value *numElements) {
result.addOperands(tagMemRef);
- result.addAttribute(getTagMapAttrName(), builder->getAffineMapAttr(tagMap));
+ result.addAttribute(getTagMapAttrName(), AffineMapAttr::get(tagMap));
result.addOperands(tagIndices);
result.addOperands(numElements);
}
builder->getIntegerAttr(builder->getIndexType(), step));
// Add the lower bound.
- result.addAttribute(getLowerBoundAttrName(),
- builder->getAffineMapAttr(lbMap));
+ result.addAttribute(getLowerBoundAttrName(), AffineMapAttr::get(lbMap));
result.addOperands(lbOperands);
// Add the upper bound.
- result.addAttribute(getUpperBoundAttrName(),
- builder->getAffineMapAttr(ubMap));
+ result.addAttribute(getUpperBoundAttrName(), AffineMapAttr::get(ubMap));
result.addOperands(ubOperands);
// Create a region and a block for the body. The argument of the region is
// for storage. Analysis passes may expand it into a multi-dimensional map
// if desired.
AffineMap map = builder.getSymbolIdentityMap();
- result.addAttribute(boundAttrName, builder.getAffineMapAttr(map));
+ result.addAttribute(boundAttrName, AffineMapAttr::get(map));
return success();
}
if (auto integerAttr = boundAttr.dyn_cast<IntegerAttr>()) {
result.attributes.pop_back();
result.addAttribute(
- boundAttrName, builder.getAffineMapAttr(
- builder.getConstantAffineMap(integerAttr.getInt())));
+ boundAttrName,
+ AffineMapAttr::get(builder.getConstantAffineMap(integerAttr.getInt())));
return success();
}
assert(operands.size() == 1 + map.getNumInputs() && "inconsistent operands");
result.addOperands(operands);
if (map)
- result.addAttribute(getMapAttrName(), builder->getAffineMapAttr(map));
+ result.addAttribute(getMapAttrName(), AffineMapAttr::get(map));
auto memrefType = operands[0]->getType().cast<MemRefType>();
result.types.push_back(memrefType.getElementType());
}
result.addOperands(memref);
result.addOperands(mapOperands);
auto memrefType = memref->getType().cast<MemRefType>();
- result.addAttribute(getMapAttrName(), builder->getAffineMapAttr(map));
+ result.addAttribute(getMapAttrName(), AffineMapAttr::get(map));
result.types.push_back(memrefType.getElementType());
}
result.addOperands(valueToStore);
result.addOperands(memref);
result.addOperands(mapOperands);
- result.addAttribute(getMapAttrName(), builder->getAffineMapAttr(map));
+ result.addAttribute(getMapAttrName(), AffineMapAttr::get(map));
}
// Use identity map.
ArrayRef<NamedAttribute> attrs) {
result.addAttribute(SymbolTable::getSymbolAttrName(),
builder->getStringAttr(name));
- result.addAttribute("type", builder->getTypeAttr(type));
+ result.addAttribute("type", TypeAttr::get(type));
if (isConstant)
result.addAttribute("constant", builder->getUnitAttr());
if (value)
}
}
- result.addAttribute("type", parser.getBuilder().getTypeAttr(types[0]));
+ result.addAttribute("type", TypeAttr::get(types[0]));
return success();
}
result.addRegion();
result.addAttribute(SymbolTable::getSymbolAttrName(),
builder->getStringAttr(name));
- result.addAttribute("type", builder->getTypeAttr(type));
+ result.addAttribute("type", TypeAttr::get(type));
result.attributes.append(attrs.begin(), attrs.end());
if (argAttrs.empty())
return;
if (!type.isa<spirv::PointerType>()) {
return parser.emitError(loc, "expected spv.ptr type");
}
- state.addAttribute(kTypeAttrName, parser.getBuilder().getTypeAttr(type));
+ state.addAttribute(kTypeAttrName, TypeAttr::get(type));
return success();
}
<< wordIndex << " of " << operands.size() << " processed";
}
auto varOp = opBuilder.create<spirv::GlobalVariableOp>(
- unknownLoc, opBuilder.getTypeAttr(type),
- opBuilder.getStringAttr(variableName), initializer);
+ unknownLoc, TypeAttr::get(type), opBuilder.getStringAttr(variableName),
+ initializer);
// Decorations.
if (decorations.count(variableID)) {
return emitError(unknownLoc, "OpTypeVector references undefined <id> ")
<< operands[1];
}
- typeMap[operands[0]] = opBuilder.getVectorType({operands[2]}, elementTy);
+ typeMap[operands[0]] = VectorType::get({operands[2]}, elementTy);
} break;
case spirv::Opcode::OpTypePointer: {
if (operands.size() != 3) {
auto resultID = operands[1];
if (auto vectorType = resultType.dyn_cast<VectorType>()) {
- auto attr = opBuilder.getDenseElementsAttr(vectorType, elements);
+ auto attr = DenseElementsAttr::get(vectorType, elements);
// For normal constants, we just record the attribute (and its type) for
// later materialization at use sites.
constantMap.try_emplace(resultID, attr, resultType);
}
rewriter.replaceOpWithNewOp<spirv::GlobalVariableOp>(
- op, rewriter.getTypeAttr(decoratedType), globalVarAttrs);
+ op, TypeAttr::get(decoratedType), globalVarAttrs);
return matchSuccess();
}
};
if (type.isIntOrIndexOrFloat())
return i1Type;
if (auto tensorType = type.dyn_cast<RankedTensorType>())
- return build->getTensorType(tensorType.getShape(), i1Type);
+ return RankedTensorType::get(tensorType.getShape(), i1Type);
if (type.isa<UnrankedTensorType>())
- return build->getTensorType(i1Type);
+ return UnrankedTensorType::get(i1Type);
if (auto vectorType = type.dyn_cast<VectorType>())
- return build->getVectorType(vectorType.getShape(), i1Type);
+ return VectorType::get(vectorType.getShape(), i1Type);
return Type();
}
static Type getTensorTypeFromMemRefType(Builder &b, Type type) {
if (auto memref = type.dyn_cast<MemRefType>())
- return b.getTensorType(memref.getShape(), memref.getElementType());
+ return RankedTensorType::get(memref.getShape(), memref.getElementType());
return b.getNoneType();
}
result.addOperands({*paddingValue});
}
result.addAttribute(getPermutationMapAttrName(),
- builder->getAffineMapAttr(permutationMap));
+ AffineMapAttr::get(permutationMap));
result.addTypes(vectorType);
}
result.addOperands({srcVector, dstMemRef});
result.addOperands(dstIndices);
result.addAttribute(getPermutationMapAttrName(),
- builder->getAffineMapAttr(permutationMap));
+ AffineMapAttr::get(permutationMap));
}
auto VectorTransferWriteOp::getIndices() -> operand_range {
return FunctionType::get(inputs, results, context);
}
-MemRefType Builder::getMemRefType(ArrayRef<int64_t> shape, Type elementType,
- ArrayRef<AffineMap> affineMapComposition,
- unsigned memorySpace) {
- return MemRefType::get(shape, elementType, affineMapComposition, memorySpace);
-}
-
-VectorType Builder::getVectorType(ArrayRef<int64_t> shape, Type elementType) {
- return VectorType::get(shape, elementType);
-}
-
-RankedTensorType Builder::getTensorType(ArrayRef<int64_t> shape,
- Type elementType) {
- return RankedTensorType::get(shape, elementType);
-}
-
-UnrankedTensorType Builder::getTensorType(Type elementType) {
- return UnrankedTensorType::get(elementType);
-}
-
TupleType Builder::getTupleType(ArrayRef<Type> elementTypes) {
return TupleType::get(elementTypes, context);
}
return StringAttr::get(bytes, context);
}
-StringAttr Builder::getStringAttr(StringRef bytes, Type type) {
- return StringAttr::get(bytes, type);
-}
-
ArrayAttr Builder::getArrayAttr(ArrayRef<Attribute> value) {
return ArrayAttr::get(value, context);
}
-AffineMapAttr Builder::getAffineMapAttr(AffineMap map) {
- return AffineMapAttr::get(map);
-}
-
-IntegerSetAttr Builder::getIntegerSetAttr(IntegerSet set) {
- return IntegerSetAttr::get(set);
-}
-
-TypeAttr Builder::getTypeAttr(Type type) { return TypeAttr::get(type); }
-
SymbolRefAttr Builder::getSymbolRefAttr(Operation *value) {
auto symName =
value->getAttrOfType<StringAttr>(SymbolTable::getSymbolAttrName());
return SymbolRefAttr::get(value, getContext());
}
-ElementsAttr Builder::getDenseElementsAttr(ShapedType type,
- ArrayRef<Attribute> values) {
- return DenseElementsAttr::get(type, values);
-}
-
-ElementsAttr Builder::getDenseIntElementsAttr(ShapedType type,
- ArrayRef<int64_t> values) {
- return DenseIntElementsAttr::get(type, values);
-}
-
-ElementsAttr Builder::getSparseElementsAttr(ShapedType type,
- DenseIntElementsAttr indices,
- DenseElementsAttr values) {
- return SparseElementsAttr::get(type, indices, values);
-}
-
-ElementsAttr Builder::getOpaqueElementsAttr(Dialect *dialect, ShapedType type,
- StringRef bytes) {
- return OpaqueElementsAttr::get(dialect, type, bytes);
-}
-
ArrayAttr Builder::getI32ArrayAttr(ArrayRef<int32_t> values) {
auto attrs = functional::map(
[this](int32_t v) -> Attribute { return getI32IntegerAttr(v); }, values);
ArrayAttr Builder::getAffineMapArrayAttr(ArrayRef<AffineMap> values) {
auto attrs = functional::map(
- [this](AffineMap v) -> Attribute { return getAffineMapAttr(v); }, values);
+ [](AffineMap v) -> Attribute { return AffineMapAttr::get(v); }, values);
return getArrayAttr(attrs);
}
auto element = getZeroAttr(vtType.getElementType());
if (!element)
return {};
- return getDenseElementsAttr(vtType, element);
+ return DenseElementsAttr::get(vtType, element);
}
default:
break;
// Affine Expressions, Affine Maps, and Integet Sets.
//===----------------------------------------------------------------------===//
-AffineMap Builder::getAffineMap(unsigned dimCount, unsigned symbolCount,
- ArrayRef<AffineExpr> results) {
- return AffineMap::get(dimCount, symbolCount, results);
-}
-
AffineExpr Builder::getAffineDimExpr(unsigned position) {
return mlir::getAffineDimExpr(position, context);
}
return mlir::getAffineConstantExpr(constant, context);
}
-IntegerSet Builder::getIntegerSet(unsigned dimCount, unsigned symbolCount,
- ArrayRef<AffineExpr> constraints,
- ArrayRef<bool> isEq) {
- return IntegerSet::get(dimCount, symbolCount, constraints, isEq);
-}
-
AffineMap Builder::getEmptyAffineMap() { return AffineMap::get(context); }
AffineMap Builder::getConstantAffineMap(int64_t val) {
AffineMap Builder::getShiftedAffineMap(AffineMap map, int64_t shift) {
SmallVector<AffineExpr, 4> shiftedResults;
shiftedResults.reserve(map.getNumResults());
- for (auto resultExpr : map.getResults()) {
+ for (auto resultExpr : map.getResults())
shiftedResults.push_back(resultExpr + shift);
- }
return AffineMap::get(map.getNumDims(), map.getNumSymbols(), shiftedResults);
}
FunctionType type, ArrayRef<NamedAttribute> attrs) {
result.addAttribute(SymbolTable::getSymbolAttrName(),
builder->getStringAttr(name));
- result.addAttribute(getTypeAttrName(), builder->getTypeAttr(type));
+ result.addAttribute(getTypeAttrName(), TypeAttr::get(type));
result.attributes.append(attrs.begin(), attrs.end());
result.addRegion();
}
std::string errorMessage;
if (auto type = funcTypeBuilder(builder, argTypes, results,
impl::VariadicFlag(isVariadic), errorMessage))
- result.addAttribute(getTypeAttrName(), builder.getTypeAttr(type));
+ result.addAttribute(getTypeAttrName(), TypeAttr::get(type));
else
return parser.emitError(signatureLocation)
<< "failed to construct function type"
if (parseAffineMapOrIntegerSetReference(map, set))
return nullptr;
if (map)
- return builder.getAffineMapAttr(map);
+ return AffineMapAttr::get(map);
assert(set);
- return builder.getIntegerSetAttr(set);
+ return IntegerSetAttr::get(set);
}
// Parse an array attribute.
default:
// Parse a type attribute.
if (Type type = parseType())
- return builder.getTypeAttr(type);
+ return TypeAttr::get(type);
return nullptr;
}
}
if (!type)
return nullptr;
- return builder.getOpaqueElementsAttr(dialect, type, llvm::fromHex(val));
+ return OpaqueElementsAttr::get(dialect, type, llvm::fromHex(val));
}
namespace {
if (exprs.empty())
map = AffineMap();
else
- map = builder.getAffineMap(numDimOperands,
- dimsAndSymbols.size() - numDimOperands, exprs);
+ map = AffineMap::get(numDimOperands, dimsAndSymbols.size() - numDimOperands,
+ exprs);
return success();
}
return AffineMap();
// Parsed a valid affine map.
- return builder.getAffineMap(numDims, numSymbols, exprs);
+ return AffineMap::get(numDims, numSymbols, exprs);
}
/// Parse an affine constraint.
if (constraints.empty()) {
/* 0 == 0 */
auto zero = getAffineConstantExpr(0, getContext());
- return builder.getIntegerSet(numDims, numSymbols, zero, true);
+ return IntegerSet::get(numDims, numSymbols, zero, true);
}
// Parsed a valid integer set.
- return builder.getIntegerSet(numDims, numSymbols, constraints, isEqs);
+ return IntegerSet::get(numDims, numSymbols, constraints, isEqs);
}
/// Parse an ambiguous reference to either and affine map or an integer set.
return failure();
// Add AffineMap attribute.
if (map) {
- mapAttr = parser.builder.getAffineMapAttr(map);
+ mapAttr = AffineMapAttr::get(map);
attrs.push_back(parser.builder.getNamedAttr(attrName, mapAttr));
}
APFloat minValue(-1.0f);
APFloat maxValue(1.0f);
ElementsAttr layerStats = DenseFPElementsAttr::get(
- b.getTensorType({2}, b.getF32Type()), {minValue, maxValue});
+ RankedTensorType::get({2}, b.getF32Type()), {minValue, maxValue});
auto statsOp = b.create<StatisticsOp>(func.getLoc(), arg, layerStats,
nullptr, nullptr);
arg->replaceAllUsesWith(statsOp);
APFloat minValue(-1.0f);
APFloat maxValue(1.0f);
ElementsAttr layerStats = DenseFPElementsAttr::get(
- b.getTensorType({2}, b.getF32Type()), {minValue, maxValue});
+ RankedTensorType::get({2}, b.getF32Type()), {minValue, maxValue});
auto statsOp = b.create<StatisticsOp>(op->getLoc(), op->getResult(0),
layerStats, nullptr, nullptr);
originalResult->replaceAllUsesWith(statsOp);
} else {
newMemSpace = oldMemRefType.getMemorySpace();
}
- auto newMemRefType = top.getMemRefType(
- newShape, oldMemRefType.getElementType(), {}, newMemSpace);
+ auto newMemRefType = MemRefType::get(newShape, oldMemRefType.getElementType(),
+ {}, newMemSpace);
// Gather alloc operands for the dynamic dimensions of the memref.
SmallVector<Value *, 4> allocOperands;
unsigned dynamicDimCount = 0;
}
auto indexRemap = zeroOffsetCount == rank
? AffineMap()
- : b.getAffineMap(outerIVs.size() + rank, 0, remapExprs);
+ : AffineMap::get(outerIVs.size() + rank, 0, remapExprs);
// Replace all users of 'oldMemRef' with 'newMemRef'.
LogicalResult res =
replaceAllMemRefUsesWith(oldMemRef, newMemRef, {}, indexRemap,
boundExprs.push_back(dim + tileSizes[i]);
boundExprs.append(origUbMap.getResults().begin(),
origUbMap.getResults().end());
- auto ubMap = b.getAffineMap(origUbMap.getNumDims() + 1,
+ auto ubMap = AffineMap::get(origUbMap.getNumDims() + 1,
origUbMap.getNumSymbols(), boundExprs);
newLoops[width + i].setUpperBound(/*operands=*/ubOperands, ubMap);
} else {
// No need of the min expression.
auto dim = b.getAffineDimExpr(0);
- auto ubMap = b.getAffineMap(1, 0, dim + tileSizes[i]);
+ auto ubMap = AffineMap::get(1, 0, dim + tileSizes[i]);
newLoops[width + i].setUpperBound(newLoops[i].getInductionVar(), ubMap);
}
}
if (!forOpIV->use_empty()) {
// iv' = iv + i, i = 1 to unrollJamFactor-1.
auto d0 = builder.getAffineDimExpr(0);
- auto bumpMap = builder.getAffineMap(1, 0, {d0 + i * step});
+ auto bumpMap = AffineMap::get(1, 0, {d0 + i * step});
auto ivUnroll =
builder.create<AffineApplyOp>(forInst->getLoc(), bumpMap, forOpIV);
operandMapping.map(forOpIV, ivUnroll);
newShape[0] = 2;
std::copy(oldShape.begin(), oldShape.end(), newShape.begin() + 1);
auto newMemRefType =
- bInner.getMemRefType(newShape, oldMemRefType.getElementType(), {},
- oldMemRefType.getMemorySpace());
+ MemRefType::get(newShape, oldMemRefType.getElementType(), {},
+ oldMemRefType.getMemorySpace());
return newMemRefType;
};
// Create 'iv mod 2' value to index the leading dimension.
auto d0 = bInner.getAffineDimExpr(0);
int64_t step = forOp.getStep();
- auto modTwoMap = bInner.getAffineMap(/*dimCount=*/1, /*symbolCount=*/0,
- {d0.floorDiv(step) % 2});
+ auto modTwoMap = AffineMap::get(/*dimCount=*/1, /*symbolCount=*/0,
+ {d0.floorDiv(step) % 2});
auto ivModTwoOp = bInner.create<AffineApplyOp>(forOp.getLoc(), modTwoMap,
forOp.getInductionVar());
for (unsigned i = 0, e = tripCountMap.getNumResults(); i < e; i++) {
auto tripCountExpr = tripCountMap.getResult(i);
bumpExprs[i] = (tripCountExpr - tripCountExpr % unrollFactor) * step;
- auto bumpMap = b.getAffineMap(tripCountMap.getNumDims(),
+ auto bumpMap = AffineMap::get(tripCountMap.getNumDims(),
tripCountMap.getNumSymbols(), bumpExprs[i]);
bumpValues[i] =
b.create<AffineApplyOp>(forOp.getLoc(), bumpMap, tripCountOperands);
operands->clear();
operands->push_back(lb);
operands->append(bumpValues.begin(), bumpValues.end());
- *map = b.getAffineMap(1 + tripCountMap.getNumResults(), 0, newUbExprs);
+ *map = AffineMap::get(1 + tripCountMap.getNumResults(), 0, newUbExprs);
// Simplify the map + operands.
fullyComposeAffineMapAndOperands(map, operands);
*map = simplifyAffineMap(*map);
if (!forOpIV->use_empty()) {
// iv' = iv + 1/2/3...unrollFactor-1;
auto d0 = builder.getAffineDimExpr(0);
- auto bumpMap = builder.getAffineMap(1, 0, {d0 + i * step});
+ auto bumpMap = AffineMap::get(1, 0, {d0 + i * step});
auto ivUnroll =
builder.create<AffineApplyOp>(forOp.getLoc(), bumpMap, forOpIV);
operandMap.map(forOpIV, ivUnroll);
auto bounds = llvm::to_vector<4>(map->getResults());
bounds.push_back(b.getAffineDimExpr(map->getNumDims()) + offset);
operands->insert(operands->begin() + map->getNumDims(), iv);
- *map = b.getAffineMap(map->getNumDims() + 1, map->getNumSymbols(), bounds);
+ *map = AffineMap::get(map->getNumDims() + 1, map->getNumSymbols(), bounds);
canonicalizeMapAndOperands(map, operands);
}
? memIndicesStart[d]
: b.create<AffineApplyOp>(
loc,
- b.getAffineMap(memAffineMap.getNumDims(),
+ AffineMap::get(memAffineMap.getNumDims(),
memAffineMap.getNumSymbols(),
memAffineMap.getResult(d)),
memIndicesStart);
SmallVector<Value *, 2> operands = {memBase, forOp.getInductionVar()};
auto memIndex = b.create<AffineApplyOp>(
loc,
- b.getAffineMap(2, 0, b.getAffineDimExpr(0) + b.getAffineDimExpr(1)),
+ AffineMap::get(2, 0, b.getAffineDimExpr(0) + b.getAffineDimExpr(1)),
operands);
memIndices.push_back(memIndex);
}
} else {
// The coordinate for the start location is just the lower bound along the
// corresponding dimension on the memory region (stored in 'offset').
- auto map = top.getAffineMap(
+ auto map = AffineMap::get(
cst->getNumDimIds() + cst->getNumSymbolIds() - rank, 0, offset);
memIndices.push_back(b.create<AffineApplyOp>(loc, map, regionSymbols));
}
if (!existingBuf) {
AffineMap fastBufferLayout = b.getMultiDimIdentityMap(rank);
auto fastMemRefType =
- top.getMemRefType(fastBufferShape, memRefType.getElementType(),
- fastBufferLayout, copyOptions.fastMemorySpace);
+ MemRefType::get(fastBufferShape, memRefType.getElementType(),
+ fastBufferLayout, copyOptions.fastMemorySpace);
// Create the fast memory space buffer just before the 'affine.for'
// operation.
} else {
// DMA generation.
// Create a tag (single element 1-d memref) for the DMA.
- auto tagMemRefType = top.getMemRefType({1}, top.getIntegerType(32), {},
- copyOptions.tagMemorySpace);
+ auto tagMemRefType = MemRefType::get({1}, top.getIntegerType(32), {},
+ copyOptions.tagMemorySpace);
auto tagMemRef = prologue.create<AllocOp>(loc, tagMemRefType);
SmallVector<Value *, 4> tagIndices({zeroIndex});
auto dimExpr = b.getAffineDimExpr(regionSymbols.size() + i);
remapExprs.push_back(dimExpr - offsets[i]);
}
- auto indexRemap = b.getAffineMap(regionSymbols.size() + rank, 0, remapExprs);
+ auto indexRemap = AffineMap::get(regionSymbols.size() + rank, 0, remapExprs);
// Record the begin since it may be invalidated by memref replacement.
Block::iterator prevOfBegin;
oldMemRefOperands.reserve(oldMemRefRank);
if (oldMap != builder.getMultiDimIdentityMap(oldMap.getNumDims())) {
for (auto resultExpr : oldMap.getResults()) {
- auto singleResMap = builder.getAffineMap(
- oldMap.getNumDims(), oldMap.getNumSymbols(), resultExpr);
+ auto singleResMap = AffineMap::get(oldMap.getNumDims(),
+ oldMap.getNumSymbols(), resultExpr);
auto afOp = builder.create<AffineApplyOp>(op->getLoc(), singleResMap,
oldMapOperands);
oldMemRefOperands.push_back(afOp);
indexRemap != builder.getMultiDimIdentityMap(indexRemap.getNumDims())) {
// Remapped indices.
for (auto resultExpr : indexRemap.getResults()) {
- auto singleResMap = builder.getAffineMap(
+ auto singleResMap = AffineMap::get(
indexRemap.getNumDims(), indexRemap.getNumSymbols(), resultExpr);
auto afOp = builder.create<AffineApplyOp>(op->getLoc(), singleResMap,
remapOperands);
state.types.push_back(result->getType());
// Add attribute for 'newMap', other Attributes do not change.
- auto newMapAttr = builder.getAffineMapAttr(newMap);
+ auto newMapAttr = AffineMapAttr::get(newMap);
for (auto namedAttr : op->getAttrs()) {
if (namedAttr.first == oldMapAttrPair.first) {
state.attributes.push_back({namedAttr.first, newMapAttr});
// Create an affine.apply for each of the map results.
sliceOps->reserve(composedMap.getNumResults());
for (auto resultExpr : composedMap.getResults()) {
- auto singleResMap = builder.getAffineMap(
- composedMap.getNumDims(), composedMap.getNumSymbols(), resultExpr);
+ auto singleResMap = AffineMap::get(composedMap.getNumDims(),
+ composedMap.getNumSymbols(), resultExpr);
sliceOps->push_back(builder.create<AffineApplyOp>(
opInst->getLoc(), singleResMap, composedOpOperands));
}
auto *oldMemRef = allocOp.getResult();
SmallVector<Value *, 4> symbolOperands(allocOp.getSymbolicOperands());
- auto newMemRefType = b.getMemRefType(newShape, memrefType.getElementType(),
+ auto newMemRefType = MemRefType::get(newShape, memrefType.getElementType(),
b.getMultiDimIdentityMap(newRank));
auto newAlloc = b.create<AllocOp>(allocOp.getLoc(), newMemRefType);
OpBuilder builder(op);
for (auto resultExpr : map.getResults()) {
auto singleResMap =
- builder.getAffineMap(map.getNumDims(), map.getNumSymbols(), resultExpr);
+ AffineMap::get(map.getNumDims(), map.getNumSymbols(), resultExpr);
auto afOp =
builder.create<AffineApplyOp>(op->getLoc(), singleResMap, mapOperands);
results.push_back(afOp);
builder.getAffineSymbolExpr(0), // s0 >= 0
builder.getAffineSymbolExpr(1) // s1 >= 0
};
- auto intSet = builder.getIntegerSet(2, 2, affineExprs, isEq);
+ auto intSet = IntegerSet::get(2, 2, affineExprs, isEq);
SmallVector<Value *, 4> affineIfArgs = {zero, zero, ten, ten};
intrinsics::affine_if(intSet, affineIfArgs, /*withElseRegion=*/false);
OpBuilder opBuilder(module.body());
auto ptrType = spirv::PointerType::get(type, spirv::StorageClass::Uniform);
opBuilder.create<spirv::GlobalVariableOp>(
- UnknownLoc::get(&context), opBuilder.getTypeAttr(ptrType),
+ UnknownLoc::get(&context), TypeAttr::get(ptrType),
opBuilder.getStringAttr(name), nullptr);
}