This is an archive of the discontinued LLVM Phabricator instance.

Differential D121762

[mlir:FunctionOpInterface] Rename the "type" attribute to "function_type"
ClosedPublic

Authored by rriddle on Mar 15 2022, 5:41 PM.

Details

Reviewers
antiagainst
ftynse
aartbik
sjarus
bondhugula
nicolasvasilache
herhut
mehdi_amini
Commits
rG4a3460a7917f: [mlir:FunctionOpInterface] Rename the "type" attribute to "function_type"
Summary

This removes any potential confusion with the getType accessors
which correspond to SSA results of an operation, and makes it
clear what the intent is (i.e. to represent the type of the function).

Depends on D121267

Diff Detail

Event Timeline

rriddle created this revision.Mar 15 2022, 5:41 PM
Herald added a reviewer: antiagainst. · View Herald TranscriptMar 15 2022, 5:41 PM
Herald added a reviewer: antiagainst. · View Herald Transcript
Herald added a reviewer: ftynse. · View Herald Transcript
Herald added a reviewer: aartbik. · View Herald Transcript
Herald added a reviewer: sjarus. · View Herald Transcript
Herald added a reviewer: bondhugula. · View Herald Transcript
Herald added projects: Restricted Project, Restricted Project. · View Herald Transcript
Herald added subscribers: awarzynski, sdasgup3, wenzhicui and 27 others. · View Herald Transcript
rriddle requested review of this revision.Mar 15 2022, 5:41 PM
Herald added a reviewer: nicolasvasilache. · View Herald TranscriptMar 15 2022, 5:41 PM
Herald added a reviewer: herhut. · View Herald Transcript
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: stephenneuendorffer, nicolasvasilache. · View Herald Transcript
rriddle added a reviewer: mehdi_amini.Mar 15 2022, 5:42 PM
Harbormaster completed remote builds in B154477: Diff 415651.Mar 15 2022, 6:05 PM
mehdi_amini accepted this revision.Mar 15 2022, 6:10 PM

Nice! Thanks :)

This revision is now accepted and ready to land.Mar 15 2022, 6:10 PM
Closed by commit rG4a3460a7917f: [mlir:FunctionOpInterface] Rename the "type" attribute to "function_type" (authored by rriddle). · Explain WhyMar 16 2022, 5:15 PM
This revision was automatically updated to reflect the committed changes.
rriddle added a commit: rG4a3460a7917f: [mlir:FunctionOpInterface] Rename the "type" attribute to "function_type".

Revision Contents

PathSize
flang/
lib/
Lower/
8 lines
24 lines
4 lines
76 lines
4 lines
22 lines
Optimizer/
Builder/
2 lines
Runtime/
2 lines
16 lines
17 lines
4 lines
8 lines
14 lines
4 lines
26 lines
6 lines
20 lines
CodeGen/
4 lines
Dialect/
2 lines
Transforms/
2 lines
mlir/
docs/
Bindings/
2 lines
examples/
toy/
Ch2/
include/
toy/
6 lines
mlir/
2 lines
4 lines
Ch3/
include/
toy/
6 lines
mlir/
2 lines
4 lines
Ch4/
include/
toy/
6 lines
mlir/
4 lines
4 lines
Ch5/
include/
toy/
6 lines
mlir/
4 lines
6 lines
4 lines
Ch6/
include/
toy/
6 lines
mlir/
4 lines
6 lines
4 lines
Ch7/
include/
toy/
6 lines
mlir/
4 lines
6 lines
7 lines
include/
mlir/
Dialect/
Func/
IR/
10 lines
GPU/
17 lines
LLVMIR/
4 lines
31 lines
PDLInterp/
IR/
6 lines
SPIRV/
IR/
12 lines
IR/
4 lines
9 lines
2 lines
lib/
Conversion/
AsyncToLLVM/
5 lines
FuncToLLVM/
11 lines
GPUCommon/
4 lines
GPUToSPIRV/
5 lines
LinalgToSPIRV/
2 lines
SPIRVToLLVM/
4 lines
Dialect/
Async/
Transforms/
3 lines
3 lines
Bufferization/
Transforms/
2 lines
Func/
IR/
8 lines
Transforms/
2 lines
2 lines
GPU/
IR/
18 lines
LLVMIR/
IR/
28 lines
Linalg/
ComprehensiveBufferize/
19 lines
MemRef/
Transforms/
4 lines
SPIRV/
IR/
12 lines
Transforms/
7 lines
2 lines
SparseTensor/
Transforms/
5 lines
Tosa/
Transforms/
2 lines
ExecutionEngine/
10 lines
Target/
Cpp/
2 lines
LLVMIR/
2 lines
SPIRV/
Serialization/
4 lines
Transforms/
Utils/
2 lines
python/
mlir/
dialects/
4 lines
test/
CAPI/
3 lines
Dialect/
GPU/
6 lines
2 lines
LLVMIR/
36 lines
IR/
4 lines
2 lines
lib/
Dialect/
Func/
2 lines
Test/
4 lines
IR/
4 lines
4 lines
mlir-lsp-server/
4 lines

Diff 416030

flang/lib/Lower/Allocatable.cpp

Show First 20 Lines • Show All 121 Lines • ▼ Show 20 Lines mlir::FuncOp callee =
box.isPointer() box.isPointer()
? fir::runtime::getRuntimeFunc<mkRTKey(PointerSetBounds)>(loc, ? fir::runtime::getRuntimeFunc<mkRTKey(PointerSetBounds)>(loc,
builder) builder)
: fir::runtime::getRuntimeFunc<mkRTKey(AllocatableSetBounds)>( : fir::runtime::getRuntimeFunc<mkRTKey(AllocatableSetBounds)>(
loc, builder); loc, builder);
llvm::SmallVector<mlir::Value> args{box.getAddr(), dimIndex, lowerBound, llvm::SmallVector<mlir::Value> args{box.getAddr(), dimIndex, lowerBound,
upperBound}; upperBound};
llvm::SmallVector<mlir::Value> operands; llvm::SmallVector<mlir::Value> operands;
for (auto [fst, snd] : llvm::zip(args, callee.getType().getInputs())) for (auto [fst, snd] : llvm::zip(args, callee.getFunctionType().getInputs()))
operands.emplace_back(builder.createConvert(loc, snd, fst)); operands.emplace_back(builder.createConvert(loc, snd, fst));
builder.create<fir::CallOp>(loc, callee, operands); builder.create<fir::CallOp>(loc, callee, operands);
} }
/// Generate runtime call to set the lengths of a character allocatable or /// Generate runtime call to set the lengths of a character allocatable or
/// pointer descriptor. /// pointer descriptor.
static void genRuntimeInitCharacter(fir::FirOpBuilder &builder, static void genRuntimeInitCharacter(fir::FirOpBuilder &builder,
mlir::Location loc, mlir::Location loc,
const fir::MutableBoxValue &box, const fir::MutableBoxValue &box,
mlir::Value len) { mlir::Value len) {
mlir::FuncOp callee = mlir::FuncOp callee =
box.isPointer() box.isPointer()
? fir::runtime::getRuntimeFunc<mkRTKey(PointerNullifyCharacter)>( ? fir::runtime::getRuntimeFunc<mkRTKey(PointerNullifyCharacter)>(
loc, builder) loc, builder)
: fir::runtime::getRuntimeFunc<mkRTKey(AllocatableInitCharacter)>( : fir::runtime::getRuntimeFunc<mkRTKey(AllocatableInitCharacter)>(
loc, builder); loc, builder);
llvm::ArrayRef<mlir::Type> inputTypes = callee.getType().getInputs(); llvm::ArrayRef<mlir::Type> inputTypes = callee.getFunctionType().getInputs();
if (inputTypes.size() != 5) if (inputTypes.size() != 5)
fir::emitFatalError( fir::emitFatalError(
loc, "AllocatableInitCharacter runtime interface not as expected"); loc, "AllocatableInitCharacter runtime interface not as expected");
llvm::SmallVector<mlir::Value> args; llvm::SmallVector<mlir::Value> args;
args.push_back(builder.createConvert(loc, inputTypes[0], box.getAddr())); args.push_back(builder.createConvert(loc, inputTypes[0], box.getAddr()));
args.push_back(builder.createConvert(loc, inputTypes[1], len)); args.push_back(builder.createConvert(loc, inputTypes[1], len));
int kind = box.getEleTy().cast<fir::CharacterType>().getFKind(); int kind = box.getEleTy().cast<fir::CharacterType>().getFKind();
args.push_back(builder.createIntegerConstant(loc, inputTypes[2], kind)); args.push_back(builder.createIntegerConstant(loc, inputTypes[2], kind));
Show All 14 Lines mlir::FuncOp callee =
box.isPointer() box.isPointer()
? fir::runtime::getRuntimeFunc<mkRTKey(PointerAllocate)>(loc, builder) ? fir::runtime::getRuntimeFunc<mkRTKey(PointerAllocate)>(loc, builder)
: fir::runtime::getRuntimeFunc<mkRTKey(AllocatableAllocate)>(loc, : fir::runtime::getRuntimeFunc<mkRTKey(AllocatableAllocate)>(loc,
builder); builder);
llvm::SmallVector<mlir::Value> args{ llvm::SmallVector<mlir::Value> args{
box.getAddr(), errorManager.hasStat, errorManager.errMsgAddr, box.getAddr(), errorManager.hasStat, errorManager.errMsgAddr,
errorManager.sourceFile, errorManager.sourceLine}; errorManager.sourceFile, errorManager.sourceLine};
llvm::SmallVector<mlir::Value> operands; llvm::SmallVector<mlir::Value> operands;
for (auto [fst, snd] : llvm::zip(args, callee.getType().getInputs())) for (auto [fst, snd] : llvm::zip(args, callee.getFunctionType().getInputs()))
operands.emplace_back(builder.createConvert(loc, snd, fst)); operands.emplace_back(builder.createConvert(loc, snd, fst));
return builder.create<fir::CallOp>(loc, callee, operands).getResult(0); return builder.create<fir::CallOp>(loc, callee, operands).getResult(0);
} }
/// Generate a runtime call to deallocate memory. /// Generate a runtime call to deallocate memory.
static mlir::Value genRuntimeDeallocate(fir::FirOpBuilder &builder, static mlir::Value genRuntimeDeallocate(fir::FirOpBuilder &builder,
mlir::Location loc, mlir::Location loc,
const fir::MutableBoxValue &box, const fir::MutableBoxValue &box,
ErrorManager &errorManager) { ErrorManager &errorManager) {
// Ensure fir.box is up-to-date before passing it to deallocate runtime. // Ensure fir.box is up-to-date before passing it to deallocate runtime.
mlir::Value boxAddress = fir::factory::getMutableIRBox(builder, loc, box); mlir::Value boxAddress = fir::factory::getMutableIRBox(builder, loc, box);
mlir::FuncOp callee = mlir::FuncOp callee =
box.isPointer() box.isPointer()
? fir::runtime::getRuntimeFunc<mkRTKey(PointerDeallocate)>(loc, ? fir::runtime::getRuntimeFunc<mkRTKey(PointerDeallocate)>(loc,
builder) builder)
: fir::runtime::getRuntimeFunc<mkRTKey(AllocatableDeallocate)>( : fir::runtime::getRuntimeFunc<mkRTKey(AllocatableDeallocate)>(
loc, builder); loc, builder);
llvm::SmallVector<mlir::Value> args{ llvm::SmallVector<mlir::Value> args{
boxAddress, errorManager.hasStat, errorManager.errMsgAddr, boxAddress, errorManager.hasStat, errorManager.errMsgAddr,
errorManager.sourceFile, errorManager.sourceLine}; errorManager.sourceFile, errorManager.sourceLine};
llvm::SmallVector<mlir::Value> operands; llvm::SmallVector<mlir::Value> operands;
for (auto [fst, snd] : llvm::zip(args, callee.getType().getInputs())) for (auto [fst, snd] : llvm::zip(args, callee.getFunctionType().getInputs()))
operands.emplace_back(builder.createConvert(loc, snd, fst)); operands.emplace_back(builder.createConvert(loc, snd, fst));
return builder.create<fir::CallOp>(loc, callee, operands).getResult(0); return builder.create<fir::CallOp>(loc, callee, operands).getResult(0);
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Allocate statement implementation // Allocate statement implementation
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 490 Lines • Show Last 20 Lines

flang/lib/Lower/ConvertExpr.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 2,044 Lines • ▼ Show 20 Lines auto allocatedResult = [&]() -> llvm::Optional<ExtValue> {
resultLengths = lengths; resultLengths = lengths;
} }
if (!extents.empty() || !lengths.empty()) { if (!extents.empty() || !lengths.empty()) {
auto *bldr = &converter.getFirOpBuilder(); auto *bldr = &converter.getFirOpBuilder();
auto stackSaveFn = fir::factory::getLlvmStackSave(builder); auto stackSaveFn = fir::factory::getLlvmStackSave(builder);
auto stackSaveSymbol = bldr->getSymbolRefAttr(stackSaveFn.getName()); auto stackSaveSymbol = bldr->getSymbolRefAttr(stackSaveFn.getName());
mlir::Value sp = mlir::Value sp =
bldr->create<fir::CallOp>(loc, stackSaveFn.getType().getResults(), bldr->create<fir::CallOp>(
loc, stackSaveFn.getFunctionType().getResults(),
stackSaveSymbol, mlir::ValueRange{}) stackSaveSymbol, mlir::ValueRange{})
.getResult(0); .getResult(0);
stmtCtx.attachCleanup([bldr, loc, sp]() { stmtCtx.attachCleanup([bldr, loc, sp]() {
auto stackRestoreFn = fir::factory::getLlvmStackRestore(*bldr); auto stackRestoreFn = fir::factory::getLlvmStackRestore(*bldr);
auto stackRestoreSymbol = auto stackRestoreSymbol =
bldr->getSymbolRefAttr(stackRestoreFn.getName()); bldr->getSymbolRefAttr(stackRestoreFn.getName());
bldr->create<fir::CallOp>(loc, stackRestoreFn.getType().getResults(), bldr->create<fir::CallOp>(
loc, stackRestoreFn.getFunctionType().getResults(),
stackRestoreSymbol, mlir::ValueRange{sp}); stackRestoreSymbol, mlir::ValueRange{sp});
}); });
} }
mlir::Value temp = mlir::Value temp =
builder.createTemporary(loc, type, ".result", extents, resultLengths); builder.createTemporary(loc, type, ".result", extents, resultLengths);
return toExtendedValue(loc, temp, extents, lengths); return toExtendedValue(loc, temp, extents, lengths);
}(); }();
if (mustPopSymMap) if (mustPopSymMap)
Show All 32 Lines ExtValue genCallOpAndResult(Fortran::lower::CallerInterface &caller,
// Casts are inserted as needed below to accommodate this. // Casts are inserted as needed below to accommodate this.
// The mlir::FuncOp type prevails, unless it has a different number of // The mlir::FuncOp type prevails, unless it has a different number of
// arguments which can happen in legal program if it was passed as a dummy // arguments which can happen in legal program if it was passed as a dummy
// procedure argument earlier with no further type information. // procedure argument earlier with no further type information.
mlir::SymbolRefAttr funcSymbolAttr; mlir::SymbolRefAttr funcSymbolAttr;
bool addHostAssociations = false; bool addHostAssociations = false;
if (!funcPointer) { if (!funcPointer) {
mlir::FunctionType funcOpType = caller.getFuncOp().getType(); mlir::FunctionType funcOpType = caller.getFuncOp().getFunctionType();
mlir::SymbolRefAttr symbolAttr = mlir::SymbolRefAttr symbolAttr =
builder.getSymbolRefAttr(caller.getMangledName()); builder.getSymbolRefAttr(caller.getMangledName());
if (callSiteType.getNumResults() == funcOpType.getNumResults() && if (callSiteType.getNumResults() == funcOpType.getNumResults() &&
callSiteType.getNumInputs() + 1 == funcOpType.getNumInputs() && callSiteType.getNumInputs() + 1 == funcOpType.getNumInputs() &&
fir::anyFuncArgsHaveAttr(caller.getFuncOp(), fir::anyFuncArgsHaveAttr(caller.getFuncOp(),
fir::getHostAssocAttrName())) { fir::getHostAssocAttrName())) {
// The number of arguments is off by one, and we're lowering a function // The number of arguments is off by one, and we're lowering a function
// with host associations. Modify call to include host associations // with host associations. Modify call to include host associations
Show All 25 Lines if (!funcPointer) {
funcPointer = funcPointer =
builder.create<fir::AddrOfOp>(loc, funcOpType, symbolAttr); builder.create<fir::AddrOfOp>(loc, funcOpType, symbolAttr);
} else { } else {
funcSymbolAttr = symbolAttr; funcSymbolAttr = symbolAttr;
} }
} }
mlir::FunctionType funcType = mlir::FunctionType funcType =
funcPointer ? callSiteType : caller.getFuncOp().getType(); funcPointer ? callSiteType : caller.getFuncOp().getFunctionType();
llvm::SmallVector<mlir::Value> operands; llvm::SmallVector<mlir::Value> operands;
// First operand of indirect call is the function pointer. Cast it to // First operand of indirect call is the function pointer. Cast it to
// required function type for the call to handle procedures that have a // required function type for the call to handle procedures that have a
// compatible interface in Fortran, but that have different signatures in // compatible interface in Fortran, but that have different signatures in
// FIR. // FIR.
if (funcPointer) { if (funcPointer) {
operands.push_back( operands.push_back(
funcPointer.getType().isa<fir::BoxProcType>() funcPointer.getType().isa<fir::BoxProcType>()
▲ Show 20 Lines • Show All 804 Lines • ▼ Show 20 Lines auto prepareUserDefinedArg =
if (!fir::isa_ref_type(from.getType())) { if (!fir::isa_ref_type(from.getType())) {
mlir::Value temp = builder.createTemporary(loc, argBaseType); mlir::Value temp = builder.createTemporary(loc, argBaseType);
builder.create<fir::StoreOp>(loc, from, temp); builder.create<fir::StoreOp>(loc, from, temp);
from = temp; from = temp;
} }
return builder.createConvert(loc, argType, from); return builder.createConvert(loc, argType, from);
}; };
assert(func.getNumArguments() == 2); assert(func.getNumArguments() == 2);
mlir::Type lhsType = func.getType().getInput(0); mlir::Type lhsType = func.getFunctionType().getInput(0);
mlir::Type rhsType = func.getType().getInput(1); mlir::Type rhsType = func.getFunctionType().getInput(1);
mlir::Value lhsArg = prepareUserDefinedArg(builder, loc, lhs, lhsType); mlir::Value lhsArg = prepareUserDefinedArg(builder, loc, lhs, lhsType);
mlir::Value rhsArg = prepareUserDefinedArg(builder, loc, rhs, rhsType); mlir::Value rhsArg = prepareUserDefinedArg(builder, loc, rhs, rhsType);
builder.create<fir::CallOp>(loc, func, mlir::ValueRange{lhsArg, rhsArg}); builder.create<fir::CallOp>(loc, func, mlir::ValueRange{lhsArg, rhsArg});
} }
/// Convert the result of a fir.array_modify to an ExtendedValue given the /// Convert the result of a fir.array_modify to an ExtendedValue given the
/// related fir.array_load. /// related fir.array_load.
static fir::ExtendedValue arrayModifyToExv(fir::FirOpBuilder &builder, static fir::ExtendedValue arrayModifyToExv(fir::FirOpBuilder &builder,
▲ Show 20 Lines • Show All 1,913 Lines • ▼ Show 20 Lines mlir::Value computeElementSize(const ExtValue &exv, mlir::Type eleTy,
mlir::Value nullPtr = builder.createNullConstant(loc, resRefTy); mlir::Value nullPtr = builder.createNullConstant(loc, resRefTy);
auto offset = builder.create<fir::CoordinateOp>( auto offset = builder.create<fir::CoordinateOp>(
loc, eleRefTy, nullPtr, mlir::ValueRange{multiplier}); loc, eleRefTy, nullPtr, mlir::ValueRange{multiplier});
return builder.createConvert(loc, idxTy, offset); return builder.createConvert(loc, idxTy, offset);
} }
/// Get the function signature of the LLVM memcpy intrinsic. /// Get the function signature of the LLVM memcpy intrinsic.
mlir::FunctionType memcpyType() { mlir::FunctionType memcpyType() {
return fir::factory::getLlvmMemcpy(builder).getType(); return fir::factory::getLlvmMemcpy(builder).getFunctionType();
} }
/// Create a call to the LLVM memcpy intrinsic. /// Create a call to the LLVM memcpy intrinsic.
void createCallMemcpy(llvm::ArrayRef<mlir::Value> args) { void createCallMemcpy(llvm::ArrayRef<mlir::Value> args) {
mlir::Location loc = getLoc(); mlir::Location loc = getLoc();
mlir::FuncOp memcpyFunc = fir::factory::getLlvmMemcpy(builder); mlir::FuncOp memcpyFunc = fir::factory::getLlvmMemcpy(builder);
mlir::SymbolRefAttr funcSymAttr = mlir::SymbolRefAttr funcSymAttr =
builder.getSymbolRefAttr(memcpyFunc.getName()); builder.getSymbolRefAttr(memcpyFunc.getName());
mlir::FunctionType funcTy = memcpyFunc.getType(); mlir::FunctionType funcTy = memcpyFunc.getFunctionType();
builder.create<fir::CallOp>(loc, funcTy.getResults(), funcSymAttr, args); builder.create<fir::CallOp>(loc, funcTy.getResults(), funcSymAttr, args);
} }
// Construct code to check for a buffer overrun and realloc the buffer when // Construct code to check for a buffer overrun and realloc the buffer when
// space is depleted. This is done between each item in the ac-value-list. // space is depleted. This is done between each item in the ac-value-list.
mlir::Value growBuffer(mlir::Value mem, mlir::Value needed, mlir::Value growBuffer(mlir::Value mem, mlir::Value needed,
mlir::Value bufferSize, mlir::Value buffSize, mlir::Value bufferSize, mlir::Value buffSize,
mlir::Value eleSz) { mlir::Value eleSz) {
mlir::Location loc = getLoc(); mlir::Location loc = getLoc();
mlir::FuncOp reallocFunc = fir::factory::getRealloc(builder); mlir::FuncOp reallocFunc = fir::factory::getRealloc(builder);
auto cond = builder.create<mlir::arith::CmpIOp>( auto cond = builder.create<mlir::arith::CmpIOp>(
loc, mlir::arith::CmpIPredicate::sle, bufferSize, needed); loc, mlir::arith::CmpIPredicate::sle, bufferSize, needed);
auto ifOp = builder.create<fir::IfOp>(loc, mem.getType(), cond, auto ifOp = builder.create<fir::IfOp>(loc, mem.getType(), cond,
/*withElseRegion=*/true); /*withElseRegion=*/true);
auto insPt = builder.saveInsertionPoint(); auto insPt = builder.saveInsertionPoint();
builder.setInsertionPointToStart(&ifOp.getThenRegion().front()); builder.setInsertionPointToStart(&ifOp.getThenRegion().front());
// Not enough space, resize the buffer. // Not enough space, resize the buffer.
mlir::IndexType idxTy = builder.getIndexType(); mlir::IndexType idxTy = builder.getIndexType();
mlir::Value two = builder.createIntegerConstant(loc, idxTy, 2); mlir::Value two = builder.createIntegerConstant(loc, idxTy, 2);
auto newSz = builder.create<mlir::arith::MulIOp>(loc, needed, two); auto newSz = builder.create<mlir::arith::MulIOp>(loc, needed, two);
builder.create<fir::StoreOp>(loc, newSz, buffSize); builder.create<fir::StoreOp>(loc, newSz, buffSize);
mlir::Value byteSz = builder.create<mlir::arith::MulIOp>(loc, newSz, eleSz); mlir::Value byteSz = builder.create<mlir::arith::MulIOp>(loc, newSz, eleSz);
mlir::SymbolRefAttr funcSymAttr = mlir::SymbolRefAttr funcSymAttr =
builder.getSymbolRefAttr(reallocFunc.getName()); builder.getSymbolRefAttr(reallocFunc.getName());
mlir::FunctionType funcTy = reallocFunc.getType(); mlir::FunctionType funcTy = reallocFunc.getFunctionType();
auto newMem = builder.create<fir::CallOp>( auto newMem = builder.create<fir::CallOp>(
loc, funcTy.getResults(), funcSymAttr, loc, funcTy.getResults(), funcSymAttr,
llvm::ArrayRef<mlir::Value>{ llvm::ArrayRef<mlir::Value>{
builder.createConvert(loc, funcTy.getInputs()[0], mem), builder.createConvert(loc, funcTy.getInputs()[0], mem),
builder.createConvert(loc, funcTy.getInputs()[1], byteSz)}); builder.createConvert(loc, funcTy.getInputs()[1], byteSz)});
mlir::Value castNewMem = mlir::Value castNewMem =
builder.createConvert(loc, mem.getType(), newMem.getResult(0)); builder.createConvert(loc, mem.getType(), newMem.getResult(0));
builder.create<fir::ResultOp>(loc, castNewMem); builder.create<fir::ResultOp>(loc, castNewMem);
▲ Show 20 Lines • Show All 1,850 Lines • Show Last 20 Lines

flang/lib/Lower/HostAssociations.cpp

Show First 20 Lines • Show All 509 Lines • ▼ Show 20 Linesvoid Fortran::lower::HostAssociations::internalProcedureBindings(
// Find the argument with the tuple type. The argument ought to be appended. // Find the argument with the tuple type. The argument ought to be appended.
fir::FirOpBuilder &builder = converter.getFirOpBuilder(); fir::FirOpBuilder &builder = converter.getFirOpBuilder();
mlir::Type argTy = getArgumentType(converter); mlir::Type argTy = getArgumentType(converter);
mlir::TupleType tupTy = unwrapTupleTy(argTy); mlir::TupleType tupTy = unwrapTupleTy(argTy);
mlir::Location loc = converter.getCurrentLocation(); mlir::Location loc = converter.getCurrentLocation();
mlir::FuncOp func = builder.getFunction(); mlir::FuncOp func = builder.getFunction();
mlir::Value tupleArg; mlir::Value tupleArg;
for (auto [ty, arg] : llvm::reverse( for (auto [ty, arg] : llvm::reverse(llvm::zip(
llvm::zip(func.getType().getInputs(), func.front().getArguments()))) func.getFunctionType().getInputs(), func.front().getArguments())))
if (ty == argTy) { if (ty == argTy) {
tupleArg = arg; tupleArg = arg;
break; break;
} }
if (!tupleArg) if (!tupleArg)
fir::emitFatalError(loc, "no host association argument found"); fir::emitFatalError(loc, "no host association argument found");
converter.bindHostAssocTuple(tupleArg); converter.bindHostAssocTuple(tupleArg);
Show All 31 Lines

flang/lib/Lower/IO.cpp

Show First 20 Lines • Show All 85 Lines • ▼ Show 20 Linesstatic constexpr std::tuple<
mkIOKey(OutputNamelist), mkIOKey(InputNamelist), mkIOKey(OutputDescriptor), mkIOKey(OutputNamelist), mkIOKey(InputNamelist), mkIOKey(OutputDescriptor),
mkIOKey(InputDescriptor), mkIOKey(OutputUnformattedBlock), mkIOKey(InputDescriptor), mkIOKey(OutputUnformattedBlock),
mkIOKey(InputUnformattedBlock), mkIOKey(OutputInteger8), mkIOKey(InputUnformattedBlock), mkIOKey(OutputInteger8),
mkIOKey(OutputInteger16), mkIOKey(OutputInteger32), mkIOKey(OutputInteger16), mkIOKey(OutputInteger32),
mkIOKey(OutputInteger64), mkIOKey(OutputInteger64),
#ifdef __SIZEOF_INT128__ #ifdef __SIZEOF_INT128__
mkIOKey(OutputInteger128), mkIOKey(OutputInteger128),
#endif #endif
mkIOKey(InputInteger), mkIOKey(InputInteger), mkIOKey(OutputReal32), mkIOKey(InputReal32),
mkIOKey(OutputReal32), mkIOKey(InputReal32), mkIOKey(OutputReal64), mkIOKey(OutputReal64), mkIOKey(InputReal64), mkIOKey(OutputComplex32),
mkIOKey(InputReal64), mkIOKey(OutputComplex32), mkIOKey(InputComplex32), mkIOKey(InputComplex32), mkIOKey(OutputComplex64), mkIOKey(InputComplex64),
mkIOKey(OutputComplex64), mkIOKey(InputComplex64), mkIOKey(OutputAscii), mkIOKey(OutputAscii), mkIOKey(InputAscii), mkIOKey(OutputLogical),
mkIOKey(InputAscii), mkIOKey(OutputLogical), mkIOKey(InputLogical), mkIOKey(InputLogical), mkIOKey(SetAccess), mkIOKey(SetAction),
mkIOKey(SetAccess), mkIOKey(SetAction), mkIOKey(SetAsynchronous), mkIOKey(SetAsynchronous), mkIOKey(SetCarriagecontrol), mkIOKey(SetEncoding),
mkIOKey(SetCarriagecontrol), mkIOKey(SetEncoding), mkIOKey(SetForm), mkIOKey(SetForm), mkIOKey(SetPosition), mkIOKey(SetRecl),
mkIOKey(SetPosition), mkIOKey(SetRecl), mkIOKey(SetStatus), mkIOKey(SetStatus), mkIOKey(SetFile), mkIOKey(GetNewUnit), mkIOKey(GetSize),
mkIOKey(SetFile), mkIOKey(GetNewUnit), mkIOKey(GetSize),
mkIOKey(GetIoLength), mkIOKey(GetIoMsg), mkIOKey(InquireCharacter), mkIOKey(GetIoLength), mkIOKey(GetIoMsg), mkIOKey(InquireCharacter),
mkIOKey(InquireLogical), mkIOKey(InquirePendingId), mkIOKey(InquireLogical), mkIOKey(InquirePendingId),
mkIOKey(InquireInteger64), mkIOKey(EndIoStatement)> mkIOKey(InquireInteger64), mkIOKey(EndIoStatement)>
newIOTable; newIOTable;
} // namespace Fortran::lower } // namespace Fortran::lower
namespace { namespace {
/// IO statements may require exceptional condition handling. A statement that /// IO statements may require exceptional condition handling. A statement that
▲ Show 20 Lines • Show All 72 Lines • ▼ Show 20 Linesstatic mlir::Value genEndIO(Fortran::lower::AbstractConverter &converter,
if (csi.ioMsgExpr) { if (csi.ioMsgExpr) {
mlir::FuncOp getIoMsg = getIORuntimeFunc<mkIOKey(GetIoMsg)>(loc, builder); mlir::FuncOp getIoMsg = getIORuntimeFunc<mkIOKey(GetIoMsg)>(loc, builder);
fir::ExtendedValue ioMsgVar = fir::ExtendedValue ioMsgVar =
converter.genExprAddr(csi.ioMsgExpr, stmtCtx, loc); converter.genExprAddr(csi.ioMsgExpr, stmtCtx, loc);
builder.create<fir::CallOp>( builder.create<fir::CallOp>(
loc, getIoMsg, loc, getIoMsg,
mlir::ValueRange{ mlir::ValueRange{
cookie, cookie,
builder.createConvert(loc, getIoMsg.getType().getInput(1), builder.createConvert(loc, getIoMsg.getFunctionType().getInput(1),
fir::getBase(ioMsgVar)), fir::getBase(ioMsgVar)),
builder.createConvert(loc, getIoMsg.getType().getInput(2), builder.createConvert(loc, getIoMsg.getFunctionType().getInput(2),
fir::getLen(ioMsgVar))}); fir::getLen(ioMsgVar))});
} }
mlir::FuncOp endIoStatement = mlir::FuncOp endIoStatement =
getIORuntimeFunc<mkIOKey(EndIoStatement)>(loc, builder); getIORuntimeFunc<mkIOKey(EndIoStatement)>(loc, builder);
auto call = builder.create<fir::CallOp>(loc, endIoStatement, auto call = builder.create<fir::CallOp>(loc, endIoStatement,
mlir::ValueRange{cookie}); mlir::ValueRange{cookie});
if (csi.ioStatExpr) { if (csi.ioStatExpr) {
mlir::Value ioStatVar = mlir::Value ioStatVar =
▲ Show 20 Lines • Show All 188 Lines • ▼ Show 20 Lines
static void genNamelistIO(Fortran::lower::AbstractConverter &converter, static void genNamelistIO(Fortran::lower::AbstractConverter &converter,
mlir::Value cookie, mlir::FuncOp funcOp, mlir::Value cookie, mlir::FuncOp funcOp,
Fortran::semantics::Symbol &symbol, bool checkResult, Fortran::semantics::Symbol &symbol, bool checkResult,
mlir::Value &ok, mlir::Value &ok,
Fortran::lower::StatementContext &stmtCtx) { Fortran::lower::StatementContext &stmtCtx) {
fir::FirOpBuilder &builder = converter.getFirOpBuilder(); fir::FirOpBuilder &builder = converter.getFirOpBuilder();
mlir::Location loc = converter.getCurrentLocation(); mlir::Location loc = converter.getCurrentLocation();
makeNextConditionalOn(builder, loc, checkResult, ok); makeNextConditionalOn(builder, loc, checkResult, ok);
mlir::Type argType = funcOp.getType().getInput(1); mlir::Type argType = funcOp.getFunctionType().getInput(1);
mlir::Value groupAddr = getNamelistGroup(converter, symbol, stmtCtx); mlir::Value groupAddr = getNamelistGroup(converter, symbol, stmtCtx);
groupAddr = builder.createConvert(loc, argType, groupAddr); groupAddr = builder.createConvert(loc, argType, groupAddr);
llvm::SmallVector<mlir::Value> args = {cookie, groupAddr}; llvm::SmallVector<mlir::Value> args = {cookie, groupAddr};
ok = builder.create<fir::CallOp>(loc, funcOp, args).getResult(0); ok = builder.create<fir::CallOp>(loc, funcOp, args).getResult(0);
} }
/// Get the output function to call for a value of the given type. /// Get the output function to call for a value of the given type.
static mlir::FuncOp getOutputFunc(mlir::Location loc, static mlir::FuncOp getOutputFunc(mlir::Location loc,
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines for (const Fortran::parser::OutputItem &item : items) {
mlir::Location loc = converter.genLocation(pExpr.source); mlir::Location loc = converter.genLocation(pExpr.source);
makeNextConditionalOn(builder, loc, checkResult, ok, inLoop); makeNextConditionalOn(builder, loc, checkResult, ok, inLoop);
const auto *expr = Fortran::semantics::GetExpr(pExpr); const auto *expr = Fortran::semantics::GetExpr(pExpr);
if (!expr) if (!expr)
fir::emitFatalError(loc, "internal error: could not get evaluate::Expr"); fir::emitFatalError(loc, "internal error: could not get evaluate::Expr");
mlir::Type itemTy = converter.genType(*expr); mlir::Type itemTy = converter.genType(*expr);
mlir::FuncOp outputFunc = getOutputFunc(loc, builder, itemTy, isFormatted); mlir::FuncOp outputFunc = getOutputFunc(loc, builder, itemTy, isFormatted);
mlir::Type argType = outputFunc.getType().getInput(1); mlir::Type argType = outputFunc.getFunctionType().getInput(1);
assert((isFormatted || argType.isa<fir::BoxType>()) && assert((isFormatted || argType.isa<fir::BoxType>()) &&
"expect descriptor for unformatted IO runtime"); "expect descriptor for unformatted IO runtime");
llvm::SmallVector<mlir::Value> outputFuncArgs = {cookie}; llvm::SmallVector<mlir::Value> outputFuncArgs = {cookie};
fir::factory::CharacterExprHelper helper{builder, loc}; fir::factory::CharacterExprHelper helper{builder, loc};
if (argType.isa<fir::BoxType>()) { if (argType.isa<fir::BoxType>()) {
mlir::Value box = fir::getBase(converter.genExprBox(*expr, stmtCtx, loc)); mlir::Value box = fir::getBase(converter.genExprBox(*expr, stmtCtx, loc));
outputFuncArgs.push_back(builder.createConvert(loc, argType, box)); outputFuncArgs.push_back(builder.createConvert(loc, argType, box));
} else if (helper.isCharacterScalar(itemTy)) { } else if (helper.isCharacterScalar(itemTy)) {
fir::ExtendedValue exv = converter.genExprAddr(expr, stmtCtx, loc); fir::ExtendedValue exv = converter.genExprAddr(expr, stmtCtx, loc);
// scalar allocatable/pointer may also get here, not clear if // scalar allocatable/pointer may also get here, not clear if
// genExprAddr will lower them as CharBoxValue or BoxValue. // genExprAddr will lower them as CharBoxValue or BoxValue.
if (!exv.getCharBox()) if (!exv.getCharBox())
llvm::report_fatal_error( llvm::report_fatal_error(
"internal error: scalar character not in CharBox"); "internal error: scalar character not in CharBox");
outputFuncArgs.push_back(builder.createConvert( outputFuncArgs.push_back(builder.createConvert(
loc, outputFunc.getType().getInput(1), fir::getBase(exv))); loc, outputFunc.getFunctionType().getInput(1), fir::getBase(exv)));
outputFuncArgs.push_back(builder.createConvert( outputFuncArgs.push_back(builder.createConvert(
loc, outputFunc.getType().getInput(2), fir::getLen(exv))); loc, outputFunc.getFunctionType().getInput(2), fir::getLen(exv)));
} else { } else {
fir::ExtendedValue itemBox = converter.genExprValue(expr, stmtCtx, loc); fir::ExtendedValue itemBox = converter.genExprValue(expr, stmtCtx, loc);
mlir::Value itemValue = fir::getBase(itemBox); mlir::Value itemValue = fir::getBase(itemBox);
if (fir::isa_complex(itemTy)) { if (fir::isa_complex(itemTy)) {
auto parts = auto parts =
fir::factory::Complex{builder, loc}.extractParts(itemValue); fir::factory::Complex{builder, loc}.extractParts(itemValue);
outputFuncArgs.push_back(parts.first); outputFuncArgs.push_back(parts.first);
outputFuncArgs.push_back(parts.second); outputFuncArgs.push_back(parts.second);
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Linesstatic void boolRefToLogical(mlir::Location loc, fir::FirOpBuilder &builder,
builder.create<fir::StoreOp>(loc, logicalValue, addr); builder.create<fir::StoreOp>(loc, logicalValue, addr);
} }
static mlir::Value createIoRuntimeCallForItem(mlir::Location loc, static mlir::Value createIoRuntimeCallForItem(mlir::Location loc,
fir::FirOpBuilder &builder, fir::FirOpBuilder &builder,
mlir::FuncOp inputFunc, mlir::FuncOp inputFunc,
mlir::Value cookie, mlir::Value cookie,
const fir::ExtendedValue &item) { const fir::ExtendedValue &item) {
mlir::Type argType = inputFunc.getType().getInput(1); mlir::Type argType = inputFunc.getFunctionType().getInput(1);
llvm::SmallVector<mlir::Value> inputFuncArgs = {cookie}; llvm::SmallVector<mlir::Value> inputFuncArgs = {cookie};
if (argType.isa<fir::BoxType>()) { if (argType.isa<fir::BoxType>()) {
mlir::Value box = fir::getBase(item); mlir::Value box = fir::getBase(item);
assert(box.getType().isa<fir::BoxType>() && "must be previously emboxed"); assert(box.getType().isa<fir::BoxType>() && "must be previously emboxed");
inputFuncArgs.push_back(builder.createConvert(loc, argType, box)); inputFuncArgs.push_back(builder.createConvert(loc, argType, box));
} else { } else {
mlir::Value itemAddr = fir::getBase(item); mlir::Value itemAddr = fir::getBase(item);
mlir::Type itemTy = fir::unwrapPassByRefType(itemAddr.getType()); mlir::Type itemTy = fir::unwrapPassByRefType(itemAddr.getType());
inputFuncArgs.push_back(builder.createConvert(loc, argType, itemAddr)); inputFuncArgs.push_back(builder.createConvert(loc, argType, itemAddr));
fir::factory::CharacterExprHelper charHelper{builder, loc}; fir::factory::CharacterExprHelper charHelper{builder, loc};
if (charHelper.isCharacterScalar(itemTy)) { if (charHelper.isCharacterScalar(itemTy)) {
mlir::Value len = fir::getLen(item); mlir::Value len = fir::getLen(item);
inputFuncArgs.push_back( inputFuncArgs.push_back(builder.createConvert(
builder.createConvert(loc, inputFunc.getType().getInput(2), len)); loc, inputFunc.getFunctionType().getInput(2), len));
} else if (itemTy.isa<mlir::IntegerType>()) { } else if (itemTy.isa<mlir::IntegerType>()) {
inputFuncArgs.push_back(builder.create<mlir::arith::ConstantOp>( inputFuncArgs.push_back(builder.create<mlir::arith::ConstantOp>(
loc, builder.getI32IntegerAttr( loc, builder.getI32IntegerAttr(
itemTy.cast<mlir::IntegerType>().getWidth() / 8))); itemTy.cast<mlir::IntegerType>().getWidth() / 8)));
} }
} }
auto call = builder.create<fir::CallOp>(loc, inputFunc, inputFuncArgs); auto call = builder.create<fir::CallOp>(loc, inputFunc, inputFuncArgs);
auto itemAddr = fir::getBase(item); auto itemAddr = fir::getBase(item);
Show All 23 Lines for (const Fortran::parser::InputItem &item : items) {
const auto *expr = Fortran::semantics::GetExpr(pVar); const auto *expr = Fortran::semantics::GetExpr(pVar);
if (!expr) if (!expr)
fir::emitFatalError(loc, "internal error: could not get evaluate::Expr"); fir::emitFatalError(loc, "internal error: could not get evaluate::Expr");
if (Fortran::evaluate::HasVectorSubscript(*expr)) { if (Fortran::evaluate::HasVectorSubscript(*expr)) {
auto vectorSubscriptBox = auto vectorSubscriptBox =
Fortran::lower::genVectorSubscriptBox(loc, converter, stmtCtx, *expr); Fortran::lower::genVectorSubscriptBox(loc, converter, stmtCtx, *expr);
mlir::FuncOp inputFunc = getInputFunc( mlir::FuncOp inputFunc = getInputFunc(
loc, builder, vectorSubscriptBox.getElementType(), isFormatted); loc, builder, vectorSubscriptBox.getElementType(), isFormatted);
const bool mustBox = inputFunc.getType().getInput(1).isa<fir::BoxType>(); const bool mustBox =
inputFunc.getFunctionType().getInput(1).isa<fir::BoxType>();
if (!checkResult) { if (!checkResult) {
auto elementalGenerator = [&](const fir::ExtendedValue &element) { auto elementalGenerator = [&](const fir::ExtendedValue &element) {
createIoRuntimeCallForItem(loc, builder, inputFunc, cookie, createIoRuntimeCallForItem(loc, builder, inputFunc, cookie,
mustBox ? builder.createBox(loc, element) mustBox ? builder.createBox(loc, element)
: element); : element);
}; };
vectorSubscriptBox.loopOverElements(builder, loc, elementalGenerator); vectorSubscriptBox.loopOverElements(builder, loc, elementalGenerator);
} else { } else {
auto elementalGenerator = auto elementalGenerator =
[&](const fir::ExtendedValue &element) -> mlir::Value { [&](const fir::ExtendedValue &element) -> mlir::Value {
return createIoRuntimeCallForItem( return createIoRuntimeCallForItem(
loc, builder, inputFunc, cookie, loc, builder, inputFunc, cookie,
mustBox ? builder.createBox(loc, element) : element); mustBox ? builder.createBox(loc, element) : element);
}; };
if (!ok) if (!ok)
ok = builder.createBool(loc, true); ok = builder.createBool(loc, true);
ok = vectorSubscriptBox.loopOverElementsWhile(builder, loc, ok = vectorSubscriptBox.loopOverElementsWhile(builder, loc,
elementalGenerator, ok); elementalGenerator, ok);
} }
continue; continue;
} }
mlir::Type itemTy = converter.genType(*expr); mlir::Type itemTy = converter.genType(*expr);
mlir::FuncOp inputFunc = getInputFunc(loc, builder, itemTy, isFormatted); mlir::FuncOp inputFunc = getInputFunc(loc, builder, itemTy, isFormatted);
auto itemExv = inputFunc.getType().getInput(1).isa<fir::BoxType>() auto itemExv = inputFunc.getFunctionType().getInput(1).isa<fir::BoxType>()
? converter.genExprBox(*expr, stmtCtx, loc) ? converter.genExprBox(*expr, stmtCtx, loc)
: converter.genExprAddr(expr, stmtCtx, loc); : converter.genExprAddr(expr, stmtCtx, loc);
ok = createIoRuntimeCallForItem(loc, builder, inputFunc, cookie, itemExv); ok = createIoRuntimeCallForItem(loc, builder, inputFunc, cookie, itemExv);
} }
} }
/// Generate an io-implied-do loop. /// Generate an io-implied-do loop.
template <typename D> template <typename D>
▲ Show 20 Lines • Show All 203 Lines • ▼ Show 20 Lines
/// Generic to build an integral argument to the runtime. /// Generic to build an integral argument to the runtime.
template <typename A, typename B> template <typename A, typename B>
mlir::Value genIntIOOption(Fortran::lower::AbstractConverter &converter, mlir::Value genIntIOOption(Fortran::lower::AbstractConverter &converter,
mlir::Location loc, mlir::Value cookie, mlir::Location loc, mlir::Value cookie,
const B &spec) { const B &spec) {
Fortran::lower::StatementContext localStatementCtx; Fortran::lower::StatementContext localStatementCtx;
fir::FirOpBuilder &builder = converter.getFirOpBuilder(); fir::FirOpBuilder &builder = converter.getFirOpBuilder();
mlir::FuncOp ioFunc = getIORuntimeFunc<A>(loc, builder); mlir::FuncOp ioFunc = getIORuntimeFunc<A>(loc, builder);
mlir::FunctionType ioFuncTy = ioFunc.getType(); mlir::FunctionType ioFuncTy = ioFunc.getFunctionType();
mlir::Value expr = fir::getBase(converter.genExprValue( mlir::Value expr = fir::getBase(converter.genExprValue(
Fortran::semantics::GetExpr(spec.v), localStatementCtx, loc)); Fortran::semantics::GetExpr(spec.v), localStatementCtx, loc));
mlir::Value val = builder.createConvert(loc, ioFuncTy.getInput(1), expr); mlir::Value val = builder.createConvert(loc, ioFuncTy.getInput(1), expr);
llvm::SmallVector<mlir::Value> ioArgs = {cookie, val}; llvm::SmallVector<mlir::Value> ioArgs = {cookie, val};
return builder.create<fir::CallOp>(loc, ioFunc, ioArgs).getResult(0); return builder.create<fir::CallOp>(loc, ioFunc, ioArgs).getResult(0);
} }
/// Generic to build a string argument to the runtime. This passes a CHARACTER /// Generic to build a string argument to the runtime. This passes a CHARACTER
/// as a pointer to the buffer and a LEN parameter. /// as a pointer to the buffer and a LEN parameter.
template <typename A, typename B> template <typename A, typename B>
mlir::Value genCharIOOption(Fortran::lower::AbstractConverter &converter, mlir::Value genCharIOOption(Fortran::lower::AbstractConverter &converter,
mlir::Location loc, mlir::Value cookie, mlir::Location loc, mlir::Value cookie,
const B &spec) { const B &spec) {
Fortran::lower::StatementContext localStatementCtx; Fortran::lower::StatementContext localStatementCtx;
fir::FirOpBuilder &builder = converter.getFirOpBuilder(); fir::FirOpBuilder &builder = converter.getFirOpBuilder();
mlir::FuncOp ioFunc = getIORuntimeFunc<A>(loc, builder); mlir::FuncOp ioFunc = getIORuntimeFunc<A>(loc, builder);
mlir::FunctionType ioFuncTy = ioFunc.getType(); mlir::FunctionType ioFuncTy = ioFunc.getFunctionType();
std::tuple<mlir::Value, mlir::Value, mlir::Value> tup = std::tuple<mlir::Value, mlir::Value, mlir::Value> tup =
lowerStringLit(converter, loc, localStatementCtx, spec, lowerStringLit(converter, loc, localStatementCtx, spec,
ioFuncTy.getInput(1), ioFuncTy.getInput(2)); ioFuncTy.getInput(1), ioFuncTy.getInput(2));
llvm::SmallVector<mlir::Value> ioArgs = {cookie, std::get<0>(tup), llvm::SmallVector<mlir::Value> ioArgs = {cookie, std::get<0>(tup),
std::get<1>(tup)}; std::get<1>(tup)};
return builder.create<fir::CallOp>(loc, ioFunc, ioArgs).getResult(0); return builder.create<fir::CallOp>(loc, ioFunc, ioArgs).getResult(0);
} }
Show All 15 Lines
template <> template <>
mlir::Value genIOOption<Fortran::parser::FileNameExpr>( mlir::Value genIOOption<Fortran::parser::FileNameExpr>(
Fortran::lower::AbstractConverter &converter, mlir::Location loc, Fortran::lower::AbstractConverter &converter, mlir::Location loc,
mlir::Value cookie, const Fortran::parser::FileNameExpr &spec) { mlir::Value cookie, const Fortran::parser::FileNameExpr &spec) {
Fortran::lower::StatementContext localStatementCtx; Fortran::lower::StatementContext localStatementCtx;
fir::FirOpBuilder &builder = converter.getFirOpBuilder(); fir::FirOpBuilder &builder = converter.getFirOpBuilder();
// has an extra KIND argument // has an extra KIND argument
mlir::FuncOp ioFunc = getIORuntimeFunc<mkIOKey(SetFile)>(loc, builder); mlir::FuncOp ioFunc = getIORuntimeFunc<mkIOKey(SetFile)>(loc, builder);
mlir::FunctionType ioFuncTy = ioFunc.getType(); mlir::FunctionType ioFuncTy = ioFunc.getFunctionType();
std::tuple<mlir::Value, mlir::Value, mlir::Value> tup = std::tuple<mlir::Value, mlir::Value, mlir::Value> tup =
lowerStringLit(converter, loc, localStatementCtx, spec, lowerStringLit(converter, loc, localStatementCtx, spec,
ioFuncTy.getInput(1), ioFuncTy.getInput(2)); ioFuncTy.getInput(1), ioFuncTy.getInput(2));
llvm::SmallVector<mlir::Value> ioArgs{cookie, std::get<0>(tup), llvm::SmallVector<mlir::Value> ioArgs{cookie, std::get<0>(tup),
std::get<1>(tup)}; std::get<1>(tup)};
return builder.create<fir::CallOp>(loc, ioFunc, ioArgs).getResult(0); return builder.create<fir::CallOp>(loc, ioFunc, ioArgs).getResult(0);
} }
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines case Fortran::parser::ConnectSpec::CharExpr::Kind::Carriagecontrol:
ioFunc = getIORuntimeFunc<mkIOKey(SetCarriagecontrol)>(loc, builder); ioFunc = getIORuntimeFunc<mkIOKey(SetCarriagecontrol)>(loc, builder);
break; break;
case Fortran::parser::ConnectSpec::CharExpr::Kind::Convert: case Fortran::parser::ConnectSpec::CharExpr::Kind::Convert:
TODO(loc, "CONVERT not part of the runtime::io interface"); TODO(loc, "CONVERT not part of the runtime::io interface");
case Fortran::parser::ConnectSpec::CharExpr::Kind::Dispose: case Fortran::parser::ConnectSpec::CharExpr::Kind::Dispose:
TODO(loc, "DISPOSE not part of the runtime::io interface"); TODO(loc, "DISPOSE not part of the runtime::io interface");
} }
Fortran::lower::StatementContext localStatementCtx; Fortran::lower::StatementContext localStatementCtx;
mlir::FunctionType ioFuncTy = ioFunc.getType(); mlir::FunctionType ioFuncTy = ioFunc.getFunctionType();
std::tuple<mlir::Value, mlir::Value, mlir::Value> tup = std::tuple<mlir::Value, mlir::Value, mlir::Value> tup =
lowerStringLit(converter, loc, localStatementCtx, lowerStringLit(converter, loc, localStatementCtx,
std::get<Fortran::parser::ScalarDefaultCharExpr>(spec.t), std::get<Fortran::parser::ScalarDefaultCharExpr>(spec.t),
ioFuncTy.getInput(1), ioFuncTy.getInput(2)); ioFuncTy.getInput(1), ioFuncTy.getInput(2));
llvm::SmallVector<mlir::Value> ioArgs = {cookie, std::get<0>(tup), llvm::SmallVector<mlir::Value> ioArgs = {cookie, std::get<0>(tup),
std::get<1>(tup)}; std::get<1>(tup)};
return builder.create<fir::CallOp>(loc, ioFunc, ioArgs).getResult(0); return builder.create<fir::CallOp>(loc, ioFunc, ioArgs).getResult(0);
} }
Show All 37 Linesmlir::Value genIOOption<Fortran::parser::IoControlSpec::CharExpr>(
case Fortran::parser::IoControlSpec::CharExpr::Kind::Round: case Fortran::parser::IoControlSpec::CharExpr::Kind::Round:
ioFunc = getIORuntimeFunc<mkIOKey(SetRound)>(loc, builder); ioFunc = getIORuntimeFunc<mkIOKey(SetRound)>(loc, builder);
break; break;
case Fortran::parser::IoControlSpec::CharExpr::Kind::Sign: case Fortran::parser::IoControlSpec::CharExpr::Kind::Sign:
ioFunc = getIORuntimeFunc<mkIOKey(SetSign)>(loc, builder); ioFunc = getIORuntimeFunc<mkIOKey(SetSign)>(loc, builder);
break; break;
} }
Fortran::lower::StatementContext localStatementCtx; Fortran::lower::StatementContext localStatementCtx;
mlir::FunctionType ioFuncTy = ioFunc.getType(); mlir::FunctionType ioFuncTy = ioFunc.getFunctionType();
std::tuple<mlir::Value, mlir::Value, mlir::Value> tup = std::tuple<mlir::Value, mlir::Value, mlir::Value> tup =
lowerStringLit(converter, loc, localStatementCtx, lowerStringLit(converter, loc, localStatementCtx,
std::get<Fortran::parser::ScalarDefaultCharExpr>(spec.t), std::get<Fortran::parser::ScalarDefaultCharExpr>(spec.t),
ioFuncTy.getInput(1), ioFuncTy.getInput(2)); ioFuncTy.getInput(1), ioFuncTy.getInput(2));
llvm::SmallVector<mlir::Value> ioArgs = {cookie, std::get<0>(tup), llvm::SmallVector<mlir::Value> ioArgs = {cookie, std::get<0>(tup),
std::get<1>(tup)}; std::get<1>(tup)};
return builder.create<fir::CallOp>(loc, ioFunc, ioArgs).getResult(0); return builder.create<fir::CallOp>(loc, ioFunc, ioArgs).getResult(0);
} }
▲ Show 20 Lines • Show All 151 Lines • ▼ Show 20 Lines std::visit(
[](const auto &) {}}, [](const auto &) {}},
spec.u); spec.u);
} }
if (!csi.hasAnyConditionSpec()) if (!csi.hasAnyConditionSpec())
return; return;
fir::FirOpBuilder &builder = converter.getFirOpBuilder(); fir::FirOpBuilder &builder = converter.getFirOpBuilder();
mlir::FuncOp enableHandlers = mlir::FuncOp enableHandlers =
getIORuntimeFunc<mkIOKey(EnableHandlers)>(loc, builder); getIORuntimeFunc<mkIOKey(EnableHandlers)>(loc, builder);
mlir::Type boolType = enableHandlers.getType().getInput(1); mlir::Type boolType = enableHandlers.getFunctionType().getInput(1);
auto boolValue = [&](bool specifierIsPresent) { auto boolValue = [&](bool specifierIsPresent) {
return builder.create<mlir::arith::ConstantOp>( return builder.create<mlir::arith::ConstantOp>(
loc, builder.getIntegerAttr(boolType, specifierIsPresent)); loc, builder.getIntegerAttr(boolType, specifierIsPresent));
}; };
llvm::SmallVector<mlir::Value> ioArgs = {cookie, llvm::SmallVector<mlir::Value> ioArgs = {cookie,
boolValue(csi.ioStatExpr != nullptr), boolValue(csi.ioStatExpr != nullptr),
boolValue(csi.hasErr), boolValue(csi.hasErr),
boolValue(csi.hasEnd), boolValue(csi.hasEnd),
▲ Show 20 Lines • Show All 338 Lines • ▼ Show 20 Lines
template <typename K, typename S> template <typename K, typename S>
static mlir::Value genBasicIOStmt(Fortran::lower::AbstractConverter &converter, static mlir::Value genBasicIOStmt(Fortran::lower::AbstractConverter &converter,
const S &stmt) { const S &stmt) {
fir::FirOpBuilder &builder = converter.getFirOpBuilder(); fir::FirOpBuilder &builder = converter.getFirOpBuilder();
Fortran::lower::StatementContext stmtCtx; Fortran::lower::StatementContext stmtCtx;
mlir::Location loc = converter.getCurrentLocation(); mlir::Location loc = converter.getCurrentLocation();
mlir::FuncOp beginFunc = getIORuntimeFunc<K>(loc, builder); mlir::FuncOp beginFunc = getIORuntimeFunc<K>(loc, builder);
mlir::FunctionType beginFuncTy = beginFunc.getType(); mlir::FunctionType beginFuncTy = beginFunc.getFunctionType();
mlir::Value unit = fir::getBase(converter.genExprValue( mlir::Value unit = fir::getBase(converter.genExprValue(
getExpr<Fortran::parser::FileUnitNumber>(stmt), stmtCtx, loc)); getExpr<Fortran::parser::FileUnitNumber>(stmt), stmtCtx, loc));
mlir::Value un = builder.createConvert(loc, beginFuncTy.getInput(0), unit); mlir::Value un = builder.createConvert(loc, beginFuncTy.getInput(0), unit);
mlir::Value file = locToFilename(converter, loc, beginFuncTy.getInput(1)); mlir::Value file = locToFilename(converter, loc, beginFuncTy.getInput(1));
mlir::Value line = locToLineNo(converter, loc, beginFuncTy.getInput(2)); mlir::Value line = locToLineNo(converter, loc, beginFuncTy.getInput(2));
auto call = builder.create<fir::CallOp>(loc, beginFunc, auto call = builder.create<fir::CallOp>(loc, beginFunc,
mlir::ValueRange{un, file, line}); mlir::ValueRange{un, file, line});
mlir::Value cookie = call.getResult(0); mlir::Value cookie = call.getResult(0);
Show All 36 LinesgenNewunitSpec(Fortran::lower::AbstractConverter &converter, mlir::Location loc,
mlir::Value cookie, mlir::Value cookie,
const std::list<Fortran::parser::ConnectSpec> &specList) { const std::list<Fortran::parser::ConnectSpec> &specList) {
for (const auto &spec : specList) for (const auto &spec : specList)
if (auto *newunit = if (auto *newunit =
std::get_if<Fortran::parser::ConnectSpec::Newunit>(&spec.u)) { std::get_if<Fortran::parser::ConnectSpec::Newunit>(&spec.u)) {
Fortran::lower::StatementContext stmtCtx; Fortran::lower::StatementContext stmtCtx;
fir::FirOpBuilder &builder = converter.getFirOpBuilder(); fir::FirOpBuilder &builder = converter.getFirOpBuilder();
mlir::FuncOp ioFunc = getIORuntimeFunc<mkIOKey(GetNewUnit)>(loc, builder); mlir::FuncOp ioFunc = getIORuntimeFunc<mkIOKey(GetNewUnit)>(loc, builder);
mlir::FunctionType ioFuncTy = ioFunc.getType(); mlir::FunctionType ioFuncTy = ioFunc.getFunctionType();
const auto *var = Fortran::semantics::GetExpr(newunit->v); const auto *var = Fortran::semantics::GetExpr(newunit->v);
mlir::Value addr = builder.createConvert( mlir::Value addr = builder.createConvert(
loc, ioFuncTy.getInput(1), loc, ioFuncTy.getInput(1),
fir::getBase(converter.genExprAddr(var, stmtCtx, loc))); fir::getBase(converter.genExprAddr(var, stmtCtx, loc)));
auto kind = builder.createIntegerConstant(loc, ioFuncTy.getInput(2), auto kind = builder.createIntegerConstant(loc, ioFuncTy.getInput(2),
var->GetType().value().kind()); var->GetType().value().kind());
llvm::SmallVector<mlir::Value> ioArgs = {cookie, addr, kind}; llvm::SmallVector<mlir::Value> ioArgs = {cookie, addr, kind};
return builder.create<fir::CallOp>(loc, ioFunc, ioArgs).getResult(0); return builder.create<fir::CallOp>(loc, ioFunc, ioArgs).getResult(0);
} }
llvm_unreachable("missing Newunit spec"); llvm_unreachable("missing Newunit spec");
} }
mlir::Value mlir::Value
Fortran::lower::genOpenStatement(Fortran::lower::AbstractConverter &converter, Fortran::lower::genOpenStatement(Fortran::lower::AbstractConverter &converter,
const Fortran::parser::OpenStmt &stmt) { const Fortran::parser::OpenStmt &stmt) {
fir::FirOpBuilder &builder = converter.getFirOpBuilder(); fir::FirOpBuilder &builder = converter.getFirOpBuilder();
Fortran::lower::StatementContext stmtCtx; Fortran::lower::StatementContext stmtCtx;
mlir::FuncOp beginFunc; mlir::FuncOp beginFunc;
llvm::SmallVector<mlir::Value> beginArgs; llvm::SmallVector<mlir::Value> beginArgs;
mlir::Location loc = converter.getCurrentLocation(); mlir::Location loc = converter.getCurrentLocation();
bool hasNewunitSpec = false; bool hasNewunitSpec = false;
if (hasSpec<Fortran::parser::FileUnitNumber>(stmt)) { if (hasSpec<Fortran::parser::FileUnitNumber>(stmt)) {
beginFunc = getIORuntimeFunc<mkIOKey(BeginOpenUnit)>(loc, builder); beginFunc = getIORuntimeFunc<mkIOKey(BeginOpenUnit)>(loc, builder);
mlir::FunctionType beginFuncTy = beginFunc.getType(); mlir::FunctionType beginFuncTy = beginFunc.getFunctionType();
mlir::Value unit = fir::getBase(converter.genExprValue( mlir::Value unit = fir::getBase(converter.genExprValue(
getExpr<Fortran::parser::FileUnitNumber>(stmt), stmtCtx, loc)); getExpr<Fortran::parser::FileUnitNumber>(stmt), stmtCtx, loc));
beginArgs.push_back( beginArgs.push_back(
builder.createConvert(loc, beginFuncTy.getInput(0), unit)); builder.createConvert(loc, beginFuncTy.getInput(0), unit));
beginArgs.push_back(locToFilename(converter, loc, beginFuncTy.getInput(1))); beginArgs.push_back(locToFilename(converter, loc, beginFuncTy.getInput(1)));
beginArgs.push_back(locToLineNo(converter, loc, beginFuncTy.getInput(2))); beginArgs.push_back(locToLineNo(converter, loc, beginFuncTy.getInput(2)));
} else { } else {
hasNewunitSpec = hasSpec<Fortran::parser::ConnectSpec::Newunit>(stmt); hasNewunitSpec = hasSpec<Fortran::parser::ConnectSpec::Newunit>(stmt);
assert(hasNewunitSpec && "missing unit specifier"); assert(hasNewunitSpec && "missing unit specifier");
beginFunc = getIORuntimeFunc<mkIOKey(BeginOpenNewUnit)>(loc, builder); beginFunc = getIORuntimeFunc<mkIOKey(BeginOpenNewUnit)>(loc, builder);
mlir::FunctionType beginFuncTy = beginFunc.getType(); mlir::FunctionType beginFuncTy = beginFunc.getFunctionType();
beginArgs.push_back(locToFilename(converter, loc, beginFuncTy.getInput(0))); beginArgs.push_back(locToFilename(converter, loc, beginFuncTy.getInput(0)));
beginArgs.push_back(locToLineNo(converter, loc, beginFuncTy.getInput(1))); beginArgs.push_back(locToLineNo(converter, loc, beginFuncTy.getInput(1)));
} }
auto cookie = auto cookie =
builder.create<fir::CallOp>(loc, beginFunc, beginArgs).getResult(0); builder.create<fir::CallOp>(loc, beginFunc, beginArgs).getResult(0);
ConditionSpecInfo csi; ConditionSpecInfo csi;
genConditionHandlerCall(converter, loc, cookie, stmt.v, csi); genConditionHandlerCall(converter, loc, cookie, stmt.v, csi);
mlir::Value ok; mlir::Value ok;
Show All 16 LinesFortran::lower::genWaitStatement(Fortran::lower::AbstractConverter &converter,
const Fortran::parser::WaitStmt &stmt) { const Fortran::parser::WaitStmt &stmt) {
fir::FirOpBuilder &builder = converter.getFirOpBuilder(); fir::FirOpBuilder &builder = converter.getFirOpBuilder();
Fortran::lower::StatementContext stmtCtx; Fortran::lower::StatementContext stmtCtx;
mlir::Location loc = converter.getCurrentLocation(); mlir::Location loc = converter.getCurrentLocation();
bool hasId = hasSpec<Fortran::parser::IdExpr>(stmt); bool hasId = hasSpec<Fortran::parser::IdExpr>(stmt);
mlir::FuncOp beginFunc = mlir::FuncOp beginFunc =
hasId ? getIORuntimeFunc<mkIOKey(BeginWait)>(loc, builder) hasId ? getIORuntimeFunc<mkIOKey(BeginWait)>(loc, builder)
: getIORuntimeFunc<mkIOKey(BeginWaitAll)>(loc, builder); : getIORuntimeFunc<mkIOKey(BeginWaitAll)>(loc, builder);
mlir::FunctionType beginFuncTy = beginFunc.getType(); mlir::FunctionType beginFuncTy = beginFunc.getFunctionType();
mlir::Value unit = fir::getBase(converter.genExprValue( mlir::Value unit = fir::getBase(converter.genExprValue(
getExpr<Fortran::parser::FileUnitNumber>(stmt), stmtCtx, loc)); getExpr<Fortran::parser::FileUnitNumber>(stmt), stmtCtx, loc));
mlir::Value un = builder.createConvert(loc, beginFuncTy.getInput(0), unit); mlir::Value un = builder.createConvert(loc, beginFuncTy.getInput(0), unit);
llvm::SmallVector<mlir::Value> args{un}; llvm::SmallVector<mlir::Value> args{un};
if (hasId) { if (hasId) {
mlir::Value id = fir::getBase(converter.genExprValue( mlir::Value id = fir::getBase(converter.genExprValue(
getExpr<Fortran::parser::IdExpr>(stmt), stmtCtx, loc)); getExpr<Fortran::parser::IdExpr>(stmt), stmtCtx, loc));
args.push_back(builder.createConvert(loc, beginFuncTy.getInput(1), id)); args.push_back(builder.createConvert(loc, beginFuncTy.getInput(1), id));
▲ Show 20 Lines • Show All 153 Lines • ▼ Show 20 LinesgenDataTransferStmt(Fortran::lower::AbstractConverter &converter,
const bool isNml = isDataTransferNamelist(stmt); const bool isNml = isDataTransferNamelist(stmt);
// Generate the begin data transfer function call. // Generate the begin data transfer function call.
mlir::FuncOp ioFunc = getBeginDataTransferFunc<isInput>( mlir::FuncOp ioFunc = getBeginDataTransferFunc<isInput>(
loc, builder, isFormatted, isList || isNml, isInternal, loc, builder, isFormatted, isList || isNml, isInternal,
isInternalWithDesc, isAsync); isInternalWithDesc, isAsync);
llvm::SmallVector<mlir::Value> ioArgs; llvm::SmallVector<mlir::Value> ioArgs;
genBeginDataTransferCallArgs<hasIOCtrl>( genBeginDataTransferCallArgs<hasIOCtrl>(
ioArgs, converter, loc, stmt, ioFunc.getType(), isFormatted, ioArgs, converter, loc, stmt, ioFunc.getFunctionType(), isFormatted,
isList || isNml, isInternal, isAsync, descRef, stmtCtx); isList || isNml, isInternal, isAsync, descRef, stmtCtx);
mlir::Value cookie = mlir::Value cookie =
builder.create<fir::CallOp>(loc, ioFunc, ioArgs).getResult(0); builder.create<fir::CallOp>(loc, ioFunc, ioArgs).getResult(0);
// Generate an EnableHandlers call and remaining specifier calls. // Generate an EnableHandlers call and remaining specifier calls.
ConditionSpecInfo csi; ConditionSpecInfo csi;
auto insertPt = builder.saveInsertionPoint(); auto insertPt = builder.saveInsertionPoint();
mlir::Value ok; mlir::Value ok;
▲ Show 20 Lines • Show All 96 Lines • ▼ Show 20 Linesmlir::Value genInquireSpec<Fortran::parser::InquireSpec::CharVar>(
Fortran::lower::StatementContext &stmtCtx) { Fortran::lower::StatementContext &stmtCtx) {
// IOMSG is handled with exception conditions // IOMSG is handled with exception conditions
if (std::get<Fortran::parser::InquireSpec::CharVar::Kind>(var.t) == if (std::get<Fortran::parser::InquireSpec::CharVar::Kind>(var.t) ==
Fortran::parser::InquireSpec::CharVar::Kind::Iomsg) Fortran::parser::InquireSpec::CharVar::Kind::Iomsg)
return {}; return {};
fir::FirOpBuilder &builder = converter.getFirOpBuilder(); fir::FirOpBuilder &builder = converter.getFirOpBuilder();
mlir::FuncOp specFunc = mlir::FuncOp specFunc =
getIORuntimeFunc<mkIOKey(InquireCharacter)>(loc, builder); getIORuntimeFunc<mkIOKey(InquireCharacter)>(loc, builder);
mlir::FunctionType specFuncTy = specFunc.getType(); mlir::FunctionType specFuncTy = specFunc.getFunctionType();
const auto *varExpr = Fortran::semantics::GetExpr( const auto *varExpr = Fortran::semantics::GetExpr(
std::get<Fortran::parser::ScalarDefaultCharVariable>(var.t)); std::get<Fortran::parser::ScalarDefaultCharVariable>(var.t));
fir::ExtendedValue str = converter.genExprAddr(varExpr, stmtCtx, loc); fir::ExtendedValue str = converter.genExprAddr(varExpr, stmtCtx, loc);
llvm::SmallVector<mlir::Value> args = { llvm::SmallVector<mlir::Value> args = {
builder.createConvert(loc, specFuncTy.getInput(0), cookie), builder.createConvert(loc, specFuncTy.getInput(0), cookie),
builder.createIntegerConstant( builder.createIntegerConstant(
loc, specFuncTy.getInput(1), loc, specFuncTy.getInput(1),
Fortran::runtime::io::HashInquiryKeyword( Fortran::runtime::io::HashInquiryKeyword(
Show All 13 Linesmlir::Value genInquireSpec<Fortran::parser::InquireSpec::IntVar>(
Fortran::lower::StatementContext &stmtCtx) { Fortran::lower::StatementContext &stmtCtx) {
// IOSTAT is handled with exception conditions // IOSTAT is handled with exception conditions
if (std::get<Fortran::parser::InquireSpec::IntVar::Kind>(var.t) == if (std::get<Fortran::parser::InquireSpec::IntVar::Kind>(var.t) ==
Fortran::parser::InquireSpec::IntVar::Kind::Iostat) Fortran::parser::InquireSpec::IntVar::Kind::Iostat)
return {}; return {};
fir::FirOpBuilder &builder = converter.getFirOpBuilder(); fir::FirOpBuilder &builder = converter.getFirOpBuilder();
mlir::FuncOp specFunc = mlir::FuncOp specFunc =
getIORuntimeFunc<mkIOKey(InquireInteger64)>(loc, builder); getIORuntimeFunc<mkIOKey(InquireInteger64)>(loc, builder);
mlir::FunctionType specFuncTy = specFunc.getType(); mlir::FunctionType specFuncTy = specFunc.getFunctionType();
const auto *varExpr = Fortran::semantics::GetExpr( const auto *varExpr = Fortran::semantics::GetExpr(
std::get<Fortran::parser::ScalarIntVariable>(var.t)); std::get<Fortran::parser::ScalarIntVariable>(var.t));
mlir::Value addr = fir::getBase(converter.genExprAddr(varExpr, stmtCtx, loc)); mlir::Value addr = fir::getBase(converter.genExprAddr(varExpr, stmtCtx, loc));
mlir::Type eleTy = fir::dyn_cast_ptrEleTy(addr.getType()); mlir::Type eleTy = fir::dyn_cast_ptrEleTy(addr.getType());
if (!eleTy) if (!eleTy)
fir::emitFatalError(loc, fir::emitFatalError(loc,
"internal error: expected a memory reference type"); "internal error: expected a memory reference type");
auto width = eleTy.cast<mlir::IntegerType>().getWidth(); auto width = eleTy.cast<mlir::IntegerType>().getWidth();
Show All 21 Linesmlir::Value genInquireSpec<Fortran::parser::InquireSpec::LogVar>(
fir::FirOpBuilder &builder = converter.getFirOpBuilder(); fir::FirOpBuilder &builder = converter.getFirOpBuilder();
auto logVarKind = std::get<Fortran::parser::InquireSpec::LogVar::Kind>(var.t); auto logVarKind = std::get<Fortran::parser::InquireSpec::LogVar::Kind>(var.t);
bool pendId = bool pendId =
idExpr && idExpr &&
logVarKind == Fortran::parser::InquireSpec::LogVar::Kind::Pending; logVarKind == Fortran::parser::InquireSpec::LogVar::Kind::Pending;
mlir::FuncOp specFunc = mlir::FuncOp specFunc =
pendId ? getIORuntimeFunc<mkIOKey(InquirePendingId)>(loc, builder) pendId ? getIORuntimeFunc<mkIOKey(InquirePendingId)>(loc, builder)
: getIORuntimeFunc<mkIOKey(InquireLogical)>(loc, builder); : getIORuntimeFunc<mkIOKey(InquireLogical)>(loc, builder);
mlir::FunctionType specFuncTy = specFunc.getType(); mlir::FunctionType specFuncTy = specFunc.getFunctionType();
mlir::Value addr = fir::getBase(converter.genExprAddr( mlir::Value addr = fir::getBase(converter.genExprAddr(
Fortran::semantics::GetExpr( Fortran::semantics::GetExpr(
std::get<Fortran::parser::Scalar< std::get<Fortran::parser::Scalar<
Fortran::parser::Logical<Fortran::parser::Variable>>>(var.t)), Fortran::parser::Logical<Fortran::parser::Variable>>>(var.t)),
stmtCtx, loc)); stmtCtx, loc));
llvm::SmallVector<mlir::Value> args = { llvm::SmallVector<mlir::Value> args = {
builder.createConvert(loc, specFuncTy.getInput(0), cookie)}; builder.createConvert(loc, specFuncTy.getInput(0), cookie)};
if (pendId) if (pendId)
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Linesmlir::Value Fortran::lower::genInquireStatement(
auto inquireFileName = [&]() -> bool { auto inquireFileName = [&]() -> bool {
return exprPair.first && exprPair.second; return exprPair.first && exprPair.second;
}; };
// Make one of three BeginInquire calls. // Make one of three BeginInquire calls.
if (inquireFileUnit()) { if (inquireFileUnit()) {
// Inquire by unit -- [UNIT=]file-unit-number. // Inquire by unit -- [UNIT=]file-unit-number.
beginFunc = getIORuntimeFunc<mkIOKey(BeginInquireUnit)>(loc, builder); beginFunc = getIORuntimeFunc<mkIOKey(BeginInquireUnit)>(loc, builder);
mlir::FunctionType beginFuncTy = beginFunc.getType(); mlir::FunctionType beginFuncTy = beginFunc.getFunctionType();
beginArgs = {builder.createConvert(loc, beginFuncTy.getInput(0), beginArgs = {builder.createConvert(loc, beginFuncTy.getInput(0),
fir::getBase(converter.genExprValue( fir::getBase(converter.genExprValue(
exprPair.first, stmtCtx, loc))), exprPair.first, stmtCtx, loc))),
locToFilename(converter, loc, beginFuncTy.getInput(1)), locToFilename(converter, loc, beginFuncTy.getInput(1)),
locToLineNo(converter, loc, beginFuncTy.getInput(2))}; locToLineNo(converter, loc, beginFuncTy.getInput(2))};
} else if (inquireFileName()) { } else if (inquireFileName()) {
// Inquire by file -- FILE=file-name-expr. // Inquire by file -- FILE=file-name-expr.
beginFunc = getIORuntimeFunc<mkIOKey(BeginInquireFile)>(loc, builder); beginFunc = getIORuntimeFunc<mkIOKey(BeginInquireFile)>(loc, builder);
mlir::FunctionType beginFuncTy = beginFunc.getType(); mlir::FunctionType beginFuncTy = beginFunc.getFunctionType();
fir::ExtendedValue file = fir::ExtendedValue file =
converter.genExprAddr(exprPair.first, stmtCtx, loc); converter.genExprAddr(exprPair.first, stmtCtx, loc);
beginArgs = { beginArgs = {
builder.createConvert(loc, beginFuncTy.getInput(0), fir::getBase(file)), builder.createConvert(loc, beginFuncTy.getInput(0), fir::getBase(file)),
builder.createConvert(loc, beginFuncTy.getInput(1), fir::getLen(file)), builder.createConvert(loc, beginFuncTy.getInput(1), fir::getLen(file)),
locToFilename(converter, loc, beginFuncTy.getInput(2)), locToFilename(converter, loc, beginFuncTy.getInput(2)),
locToLineNo(converter, loc, beginFuncTy.getInput(3))}; locToLineNo(converter, loc, beginFuncTy.getInput(3))};
} else { } else {
// Inquire by output list -- IOLENGTH=scalar-int-variable. // Inquire by output list -- IOLENGTH=scalar-int-variable.
const auto *ioLength = const auto *ioLength =
std::get_if<Fortran::parser::InquireStmt::Iolength>(&stmt.u); std::get_if<Fortran::parser::InquireStmt::Iolength>(&stmt.u);
assert(ioLength && "must have an IOLENGTH specifier"); assert(ioLength && "must have an IOLENGTH specifier");
beginFunc = getIORuntimeFunc<mkIOKey(BeginInquireIoLength)>(loc, builder); beginFunc = getIORuntimeFunc<mkIOKey(BeginInquireIoLength)>(loc, builder);
mlir::FunctionType beginFuncTy = beginFunc.getType(); mlir::FunctionType beginFuncTy = beginFunc.getFunctionType();
beginArgs = {locToFilename(converter, loc, beginFuncTy.getInput(0)), beginArgs = {locToFilename(converter, loc, beginFuncTy.getInput(0)),
locToLineNo(converter, loc, beginFuncTy.getInput(1))}; locToLineNo(converter, loc, beginFuncTy.getInput(1))};
auto cookie = auto cookie =
builder.create<fir::CallOp>(loc, beginFunc, beginArgs).getResult(0); builder.create<fir::CallOp>(loc, beginFunc, beginArgs).getResult(0);
mlir::Value ok; mlir::Value ok;
genOutputItemList( genOutputItemList(
converter, cookie, converter, cookie,
std::get<std::list<Fortran::parser::OutputItem>>(ioLength->t), std::get<std::list<Fortran::parser::OutputItem>>(ioLength->t),
Show All 32 Lines

flang/lib/Lower/IntrinsicCall.cpp

Show First 20 Lines • Show All 1,384 Lines • ▼ Show 20 Lines if constexpr (std::is_same_v<GeneratorType, SubroutineGenerator>) {
"expect one result for intrinsic function wrapper type"); "expect one result for intrinsic function wrapper type");
mlir::Type resultType = funcType.getResult(0); mlir::Type resultType = funcType.getResult(0);
auto result = auto result =
localLib.invokeGenerator(generator, resultType, localArguments); localLib.invokeGenerator(generator, resultType, localArguments);
localBuilder->create<mlir::func::ReturnOp>(localLoc, result); localBuilder->create<mlir::func::ReturnOp>(localLoc, result);
} }
} else { } else {
// Wrapper was already built, ensure it has the sought type // Wrapper was already built, ensure it has the sought type
assert(function.getType() == funcType && assert(function.getFunctionType() == funcType &&
"conflict between intrinsic wrapper types"); "conflict between intrinsic wrapper types");
} }
return function; return function;
} }
/// Helpers to detect absent optional (not yet supported in outlining). /// Helpers to detect absent optional (not yet supported in outlining).
bool static hasAbsentOptional(llvm::ArrayRef<fir::ExtendedValue> args) { bool static hasAbsentOptional(llvm::ArrayRef<fir::ExtendedValue> args) {
for (const fir::ExtendedValue &arg : args) for (const fir::ExtendedValue &arg : args)
Show All 28 LinesIntrinsicLibrary::getRuntimeCallGenerator(llvm::StringRef name,
mlir::FuncOp funcOp = getRuntimeFunction(loc, builder, name, soughtFuncType); mlir::FuncOp funcOp = getRuntimeFunction(loc, builder, name, soughtFuncType);
if (!funcOp) { if (!funcOp) {
std::string buffer("not yet implemented: missing intrinsic lowering: "); std::string buffer("not yet implemented: missing intrinsic lowering: ");
llvm::raw_string_ostream sstream(buffer); llvm::raw_string_ostream sstream(buffer);
sstream << name << "\nrequested type was: " << soughtFuncType << '\n'; sstream << name << "\nrequested type was: " << soughtFuncType << '\n';
fir::emitFatalError(loc, buffer); fir::emitFatalError(loc, buffer);
} }
mlir::FunctionType actualFuncType = funcOp.getType(); mlir::FunctionType actualFuncType = funcOp.getFunctionType();
assert(actualFuncType.getNumResults() == soughtFuncType.getNumResults() && assert(actualFuncType.getNumResults() == soughtFuncType.getNumResults() &&
actualFuncType.getNumInputs() == soughtFuncType.getNumInputs() && actualFuncType.getNumInputs() == soughtFuncType.getNumInputs() &&
actualFuncType.getNumResults() == 1 && "Bad intrinsic match"); actualFuncType.getNumResults() == 1 && "Bad intrinsic match");
return [funcOp, actualFuncType, return [funcOp, actualFuncType,
soughtFuncType](fir::FirOpBuilder &builder, mlir::Location loc, soughtFuncType](fir::FirOpBuilder &builder, mlir::Location loc,
llvm::ArrayRef<mlir::Value> args) { llvm::ArrayRef<mlir::Value> args) {
llvm::SmallVector<mlir::Value> convertedArguments; llvm::SmallVector<mlir::Value> convertedArguments;
▲ Show 20 Lines • Show All 1,320 Lines • Show Last 20 Lines

flang/lib/Lower/Runtime.cpp

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Lines if (const auto &code =
auto expr = auto expr =
converter.genExprValue(*Fortran::semantics::GetExpr(*code), stmtCtx); converter.genExprValue(*Fortran::semantics::GetExpr(*code), stmtCtx);
LLVM_DEBUG(llvm::dbgs() << "stop expression: "; expr.dump(); LLVM_DEBUG(llvm::dbgs() << "stop expression: "; expr.dump();
llvm::dbgs() << '\n'); llvm::dbgs() << '\n');
expr.match( expr.match(
[&](const fir::CharBoxValue &x) { [&](const fir::CharBoxValue &x) {
callee = fir::runtime::getRuntimeFunc<mkRTKey(StopStatementText)>( callee = fir::runtime::getRuntimeFunc<mkRTKey(StopStatementText)>(
loc, builder); loc, builder);
calleeType = callee.getType(); calleeType = callee.getFunctionType();
// Creates a pair of operands for the CHARACTER and its LEN. // Creates a pair of operands for the CHARACTER and its LEN.
operands.push_back( operands.push_back(
builder.createConvert(loc, calleeType.getInput(0), x.getAddr())); builder.createConvert(loc, calleeType.getInput(0), x.getAddr()));
operands.push_back( operands.push_back(
builder.createConvert(loc, calleeType.getInput(1), x.getLen())); builder.createConvert(loc, calleeType.getInput(1), x.getLen()));
}, },
[&](fir::UnboxedValue x) { [&](fir::UnboxedValue x) {
callee = fir::runtime::getRuntimeFunc<mkRTKey(StopStatement)>( callee = fir::runtime::getRuntimeFunc<mkRTKey(StopStatement)>(
loc, builder); loc, builder);
calleeType = callee.getType(); calleeType = callee.getFunctionType();
mlir::Value cast = mlir::Value cast =
builder.createConvert(loc, calleeType.getInput(0), x); builder.createConvert(loc, calleeType.getInput(0), x);
operands.push_back(cast); operands.push_back(cast);
}, },
[&](auto) { [&](auto) {
mlir::emitError(loc, "unhandled expression in STOP"); mlir::emitError(loc, "unhandled expression in STOP");
std::exit(1); std::exit(1);
}); });
} else { } else {
callee = fir::runtime::getRuntimeFunc<mkRTKey(StopStatement)>(loc, builder); callee = fir::runtime::getRuntimeFunc<mkRTKey(StopStatement)>(loc, builder);
calleeType = callee.getType(); calleeType = callee.getFunctionType();
operands.push_back( operands.push_back(
builder.createIntegerConstant(loc, calleeType.getInput(0), 0)); builder.createIntegerConstant(loc, calleeType.getInput(0), 0));
} }
// Second operand indicates ERROR STOP // Second operand indicates ERROR STOP
bool isError = std::get<Fortran::parser::StopStmt::Kind>(stmt.t) == bool isError = std::get<Fortran::parser::StopStmt::Kind>(stmt.t) ==
Fortran::parser::StopStmt::Kind::ErrorStop; Fortran::parser::StopStmt::Kind::ErrorStop;
operands.push_back(builder.createIntegerConstant( operands.push_back(builder.createIntegerConstant(
Show All 29 Lines
mlir::Value Fortran::lower::genAssociated(fir::FirOpBuilder &builder, mlir::Value Fortran::lower::genAssociated(fir::FirOpBuilder &builder,
mlir::Location loc, mlir::Location loc,
mlir::Value pointer, mlir::Value pointer,
mlir::Value target) { mlir::Value target) {
mlir::FuncOp func = mlir::FuncOp func =
fir::runtime::getRuntimeFunc<mkRTKey(PointerIsAssociatedWith)>(loc, fir::runtime::getRuntimeFunc<mkRTKey(PointerIsAssociatedWith)>(loc,
builder); builder);
llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments( llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments(
builder, loc, func.getType(), pointer, target); builder, loc, func.getFunctionType(), pointer, target);
return builder.create<fir::CallOp>(loc, func, args).getResult(0); return builder.create<fir::CallOp>(loc, func, args).getResult(0);
} }
mlir::Value Fortran::lower::genCpuTime(fir::FirOpBuilder &builder, mlir::Value Fortran::lower::genCpuTime(fir::FirOpBuilder &builder,
mlir::Location loc) { mlir::Location loc) {
mlir::FuncOp func = mlir::FuncOp func =
fir::runtime::getRuntimeFunc<mkRTKey(CpuTime)>(loc, builder); fir::runtime::getRuntimeFunc<mkRTKey(CpuTime)>(loc, builder);
return builder.create<fir::CallOp>(loc, func, llvm::None).getResult(0); return builder.create<fir::CallOp>(loc, func, llvm::None).getResult(0);
} }
void Fortran::lower::genDateAndTime(fir::FirOpBuilder &builder, void Fortran::lower::genDateAndTime(fir::FirOpBuilder &builder,
mlir::Location loc, mlir::Location loc,
llvm::Optional<fir::CharBoxValue> date, llvm::Optional<fir::CharBoxValue> date,
llvm::Optional<fir::CharBoxValue> time, llvm::Optional<fir::CharBoxValue> time,
llvm::Optional<fir::CharBoxValue> zone, llvm::Optional<fir::CharBoxValue> zone,
mlir::Value values) { mlir::Value values) {
mlir::FuncOp callee = mlir::FuncOp callee =
fir::runtime::getRuntimeFunc<mkRTKey(DateAndTime)>(loc, builder); fir::runtime::getRuntimeFunc<mkRTKey(DateAndTime)>(loc, builder);
mlir::FunctionType funcTy = callee.getType(); mlir::FunctionType funcTy = callee.getFunctionType();
mlir::Type idxTy = builder.getIndexType(); mlir::Type idxTy = builder.getIndexType();
mlir::Value zero; mlir::Value zero;
auto splitArg = [&](llvm::Optional<fir::CharBoxValue> arg, auto splitArg = [&](llvm::Optional<fir::CharBoxValue> arg,
mlir::Value &buffer, mlir::Value &len) { mlir::Value &buffer, mlir::Value &len) {
if (arg) { if (arg) {
buffer = arg->getBuffer(); buffer = arg->getBuffer();
len = arg->getLen(); len = arg->getLen();
} else { } else {
Show All 24 Lines
} }
void Fortran::lower::genRandomInit(fir::FirOpBuilder &builder, void Fortran::lower::genRandomInit(fir::FirOpBuilder &builder,
mlir::Location loc, mlir::Value repeatable, mlir::Location loc, mlir::Value repeatable,
mlir::Value imageDistinct) { mlir::Value imageDistinct) {
mlir::FuncOp func = mlir::FuncOp func =
fir::runtime::getRuntimeFunc<mkRTKey(RandomInit)>(loc, builder); fir::runtime::getRuntimeFunc<mkRTKey(RandomInit)>(loc, builder);
llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments( llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments(
builder, loc, func.getType(), repeatable, imageDistinct); builder, loc, func.getFunctionType(), repeatable, imageDistinct);
builder.create<fir::CallOp>(loc, func, args); builder.create<fir::CallOp>(loc, func, args);
} }
void Fortran::lower::genRandomNumber(fir::FirOpBuilder &builder, void Fortran::lower::genRandomNumber(fir::FirOpBuilder &builder,
mlir::Location loc, mlir::Value harvest) { mlir::Location loc, mlir::Value harvest) {
mlir::FuncOp func = mlir::FuncOp func =
fir::runtime::getRuntimeFunc<mkRTKey(RandomNumber)>(loc, builder); fir::runtime::getRuntimeFunc<mkRTKey(RandomNumber)>(loc, builder);
mlir::FunctionType funcTy = func.getType(); mlir::FunctionType funcTy = func.getFunctionType();
mlir::Value sourceFile = fir::factory::locationToFilename(builder, loc); mlir::Value sourceFile = fir::factory::locationToFilename(builder, loc);
mlir::Value sourceLine = mlir::Value sourceLine =
fir::factory::locationToLineNo(builder, loc, funcTy.getInput(2)); fir::factory::locationToLineNo(builder, loc, funcTy.getInput(2));
llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments( llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments(
builder, loc, funcTy, harvest, sourceFile, sourceLine); builder, loc, funcTy, harvest, sourceFile, sourceLine);
builder.create<fir::CallOp>(loc, func, args); builder.create<fir::CallOp>(loc, func, args);
} }
Show All 16 Lines case 1:
func = fir::runtime::getRuntimeFunc<mkRTKey(RandomSeedPut)>(loc, builder); func = fir::runtime::getRuntimeFunc<mkRTKey(RandomSeedPut)>(loc, builder);
break; break;
case 2: case 2:
func = fir::runtime::getRuntimeFunc<mkRTKey(RandomSeedGet)>(loc, builder); func = fir::runtime::getRuntimeFunc<mkRTKey(RandomSeedGet)>(loc, builder);
break; break;
default: default:
llvm::report_fatal_error("invalid RANDOM_SEED argument index"); llvm::report_fatal_error("invalid RANDOM_SEED argument index");
} }
mlir::FunctionType funcTy = func.getType(); mlir::FunctionType funcTy = func.getFunctionType();
mlir::Value sourceFile = fir::factory::locationToFilename(builder, loc); mlir::Value sourceFile = fir::factory::locationToFilename(builder, loc);
mlir::Value sourceLine = mlir::Value sourceLine =
fir::factory::locationToLineNo(builder, loc, funcTy.getInput(2)); fir::factory::locationToLineNo(builder, loc, funcTy.getInput(2));
llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments( llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments(
builder, loc, funcTy, argBox, sourceFile, sourceLine); builder, loc, funcTy, argBox, sourceFile, sourceLine);
builder.create<fir::CallOp>(loc, func, args); builder.create<fir::CallOp>(loc, func, args);
} }
/// generate runtime call to transfer intrinsic with no size argument /// generate runtime call to transfer intrinsic with no size argument
void Fortran::lower::genTransfer(fir::FirOpBuilder &builder, mlir::Location loc, void Fortran::lower::genTransfer(fir::FirOpBuilder &builder, mlir::Location loc,
mlir::Value resultBox, mlir::Value sourceBox, mlir::Value resultBox, mlir::Value sourceBox,
mlir::Value moldBox) { mlir::Value moldBox) {
mlir::FuncOp func = mlir::FuncOp func =
fir::runtime::getRuntimeFunc<mkRTKey(Transfer)>(loc, builder); fir::runtime::getRuntimeFunc<mkRTKey(Transfer)>(loc, builder);
mlir::FunctionType fTy = func.getType(); mlir::FunctionType fTy = func.getFunctionType();
mlir::Value sourceFile = fir::factory::locationToFilename(builder, loc); mlir::Value sourceFile = fir::factory::locationToFilename(builder, loc);
mlir::Value sourceLine = mlir::Value sourceLine =
fir::factory::locationToLineNo(builder, loc, fTy.getInput(4)); fir::factory::locationToLineNo(builder, loc, fTy.getInput(4));
llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments( llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments(
builder, loc, fTy, resultBox, sourceBox, moldBox, sourceFile, sourceLine); builder, loc, fTy, resultBox, sourceBox, moldBox, sourceFile, sourceLine);
builder.create<fir::CallOp>(loc, func, args); builder.create<fir::CallOp>(loc, func, args);
} }
/// generate runtime call to transfer intrinsic with size argument /// generate runtime call to transfer intrinsic with size argument
void Fortran::lower::genTransferSize(fir::FirOpBuilder &builder, void Fortran::lower::genTransferSize(fir::FirOpBuilder &builder,
mlir::Location loc, mlir::Value resultBox, mlir::Location loc, mlir::Value resultBox,
mlir::Value sourceBox, mlir::Value moldBox, mlir::Value sourceBox, mlir::Value moldBox,
mlir::Value size) { mlir::Value size) {
mlir::FuncOp func = mlir::FuncOp func =
fir::runtime::getRuntimeFunc<mkRTKey(TransferSize)>(loc, builder); fir::runtime::getRuntimeFunc<mkRTKey(TransferSize)>(loc, builder);
mlir::FunctionType fTy = func.getType(); mlir::FunctionType fTy = func.getFunctionType();
mlir::Value sourceFile = fir::factory::locationToFilename(builder, loc); mlir::Value sourceFile = fir::factory::locationToFilename(builder, loc);
mlir::Value sourceLine = mlir::Value sourceLine =
fir::factory::locationToLineNo(builder, loc, fTy.getInput(4)); fir::factory::locationToLineNo(builder, loc, fTy.getInput(4));
llvm::SmallVector<mlir::Value> args = llvm::SmallVector<mlir::Value> args =
fir::runtime::createArguments(builder, loc, fTy, resultBox, sourceBox, fir::runtime::createArguments(builder, loc, fTy, resultBox, sourceBox,
moldBox, sourceFile, sourceLine, size); moldBox, sourceFile, sourceLine, size);
builder.create<fir::CallOp>(loc, func, args); builder.create<fir::CallOp>(loc, func, args);
} }
/// generate system_clock runtime call/s /// generate system_clock runtime call/s
/// all intrinsic arguments are optional and may appear here as mlir::Value{} /// all intrinsic arguments are optional and may appear here as mlir::Value{}
void Fortran::lower::genSystemClock(fir::FirOpBuilder &builder, void Fortran::lower::genSystemClock(fir::FirOpBuilder &builder,
mlir::Location loc, mlir::Value count, mlir::Location loc, mlir::Value count,
mlir::Value rate, mlir::Value max) { mlir::Value rate, mlir::Value max) {
auto makeCall = [&](mlir::FuncOp func, mlir::Value arg) { auto makeCall = [&](mlir::FuncOp func, mlir::Value arg) {
mlir::Type kindTy = func.getType().getInput(0); mlir::Type kindTy = func.getFunctionType().getInput(0);
int integerKind = 8; int integerKind = 8;
if (auto intType = if (auto intType =
fir::unwrapRefType(arg.getType()).dyn_cast<mlir::IntegerType>()) fir::unwrapRefType(arg.getType()).dyn_cast<mlir::IntegerType>())
integerKind = intType.getWidth() / 8; integerKind = intType.getWidth() / 8;
mlir::Value kind = builder.createIntegerConstant(loc, kindTy, integerKind); mlir::Value kind = builder.createIntegerConstant(loc, kindTy, integerKind);
mlir::Value res = mlir::Value res =
builder.create<fir::CallOp>(loc, func, mlir::ValueRange{kind}) builder.create<fir::CallOp>(loc, func, mlir::ValueRange{kind})
.getResult(0); .getResult(0);
Show All 12 Lines

flang/lib/Optimizer/Builder/Character.cpp

Show First 20 Lines • Show All 359 Lines • ▼ Show 20 Linesvoid fir::factory::CharacterExprHelper::createCopy(
if (getCharacterKind(dest.getBuffer().getType()) == kind) { if (getCharacterKind(dest.getBuffer().getType()) == kind) {
auto bytes = builder.getKindMap().getCharacterBitsize(kind) / 8; auto bytes = builder.getKindMap().getCharacterBitsize(kind) / 8;
auto i64Ty = builder.getI64Type(); auto i64Ty = builder.getI64Type();
auto kindBytes = builder.createIntegerConstant(loc, i64Ty, bytes); auto kindBytes = builder.createIntegerConstant(loc, i64Ty, bytes);
auto castCount = builder.createConvert(loc, i64Ty, count); auto castCount = builder.createConvert(loc, i64Ty, count);
auto totalBytes = builder.create<arith::MulIOp>(loc, kindBytes, castCount); auto totalBytes = builder.create<arith::MulIOp>(loc, kindBytes, castCount);
auto notVolatile = builder.createBool(loc, false); auto notVolatile = builder.createBool(loc, false);
auto memmv = getLlvmMemmove(builder); auto memmv = getLlvmMemmove(builder);
auto argTys = memmv.getType().getInputs(); auto argTys = memmv.getFunctionType().getInputs();
auto toPtr = builder.createConvert(loc, argTys[0], toBuff); auto toPtr = builder.createConvert(loc, argTys[0], toBuff);
auto fromPtr = builder.createConvert(loc, argTys[1], fromBuff); auto fromPtr = builder.createConvert(loc, argTys[1], fromBuff);
builder.create<fir::CallOp>( builder.create<fir::CallOp>(
loc, memmv, mlir::ValueRange{toPtr, fromPtr, totalBytes, notVolatile}); loc, memmv, mlir::ValueRange{toPtr, fromPtr, totalBytes, notVolatile});
return; return;
} }
// Convert a CHARACTER of one KIND into a CHARACTER of another KIND. // Convert a CHARACTER of one KIND into a CHARACTER of another KIND.
▲ Show 20 Lines • Show All 407 Lines • Show Last 20 Lines

flang/lib/Optimizer/Builder/Runtime/Assign.cpp

Show All 10 Lines
#include "flang/Optimizer/Builder/Runtime/RTBuilder.h" #include "flang/Optimizer/Builder/Runtime/RTBuilder.h"
#include "flang/Runtime/assign.h" #include "flang/Runtime/assign.h"
using namespace Fortran::runtime; using namespace Fortran::runtime;
void fir::runtime::genAssign(fir::FirOpBuilder &builder, mlir::Location loc, void fir::runtime::genAssign(fir::FirOpBuilder &builder, mlir::Location loc,
mlir::Value destBox, mlir::Value sourceBox) { mlir::Value destBox, mlir::Value sourceBox) {
auto func = fir::runtime::getRuntimeFunc<mkRTKey(Assign)>(loc, builder); auto func = fir::runtime::getRuntimeFunc<mkRTKey(Assign)>(loc, builder);
auto fTy = func.getType(); auto fTy = func.getFunctionType();
auto sourceFile = fir::factory::locationToFilename(builder, loc); auto sourceFile = fir::factory::locationToFilename(builder, loc);
auto sourceLine = auto sourceLine =
fir::factory::locationToLineNo(builder, loc, fTy.getInput(3)); fir::factory::locationToLineNo(builder, loc, fTy.getInput(3));
auto args = fir::runtime::createArguments(builder, loc, fTy, destBox, auto args = fir::runtime::createArguments(builder, loc, fTy, destBox,
sourceBox, sourceFile, sourceLine); sourceBox, sourceFile, sourceLine);
builder.create<fir::CallOp>(loc, func, args); builder.create<fir::CallOp>(loc, func, args);
} }

flang/lib/Optimizer/Builder/Runtime/Character.cpp

Show All 20 Lines
/// verify. These are the descriptor based implementations that take four /// verify. These are the descriptor based implementations that take four
/// arguments (string1, string2, back, kind). /// arguments (string1, string2, back, kind).
template <typename FN> template <typename FN>
static void genCharacterSearch(FN func, fir::FirOpBuilder &builder, static void genCharacterSearch(FN func, fir::FirOpBuilder &builder,
mlir::Location loc, mlir::Value resultBox, mlir::Location loc, mlir::Value resultBox,
mlir::Value string1Box, mlir::Value string2Box, mlir::Value string1Box, mlir::Value string2Box,
mlir::Value backBox, mlir::Value kind) { mlir::Value backBox, mlir::Value kind) {
auto fTy = func.getType(); auto fTy = func.getFunctionType();
auto sourceFile = fir::factory::locationToFilename(builder, loc); auto sourceFile = fir::factory::locationToFilename(builder, loc);
auto sourceLine = auto sourceLine =
fir::factory::locationToLineNo(builder, loc, fTy.getInput(6)); fir::factory::locationToLineNo(builder, loc, fTy.getInput(6));
auto args = fir::runtime::createArguments(builder, loc, fTy, resultBox, auto args = fir::runtime::createArguments(builder, loc, fTy, resultBox,
string1Box, string2Box, backBox, string1Box, string2Box, backBox,
kind, sourceFile, sourceLine); kind, sourceFile, sourceLine);
builder.create<fir::CallOp>(loc, func, args); builder.create<fir::CallOp>(loc, func, args);
Show All 23 Lines
/// \p resultBox must be an unallocated allocatable used for the temporary /// \p resultBox must be an unallocated allocatable used for the temporary
/// result. \p StringBox must be a fir.box describing the adjustr string /// result. \p StringBox must be a fir.box describing the adjustr string
/// argument. The \p adjustFunc should be a mlir::FuncOp for the appropriate /// argument. The \p adjustFunc should be a mlir::FuncOp for the appropriate
/// runtime entry function. /// runtime entry function.
static void genAdjust(fir::FirOpBuilder &builder, mlir::Location loc, static void genAdjust(fir::FirOpBuilder &builder, mlir::Location loc,
mlir::Value resultBox, mlir::Value stringBox, mlir::Value resultBox, mlir::Value stringBox,
mlir::FuncOp &adjustFunc) { mlir::FuncOp &adjustFunc) {
auto fTy = adjustFunc.getType(); auto fTy = adjustFunc.getFunctionType();
auto sourceLine = auto sourceLine =
fir::factory::locationToLineNo(builder, loc, fTy.getInput(3)); fir::factory::locationToLineNo(builder, loc, fTy.getInput(3));
auto sourceFile = fir::factory::locationToFilename(builder, loc); auto sourceFile = fir::factory::locationToFilename(builder, loc);
auto args = fir::runtime::createArguments(builder, loc, fTy, resultBox, auto args = fir::runtime::createArguments(builder, loc, fTy, resultBox,
stringBox, sourceFile, sourceLine); stringBox, sourceFile, sourceLine);
builder.create<fir::CallOp>(loc, adjustFunc, args); builder.create<fir::CallOp>(loc, adjustFunc, args);
} }
Show All 28 Lines case 2:
break; break;
case 4: case 4:
beginFunc = fir::runtime::getRuntimeFunc<mkRTKey(CharacterCompareScalar4)>( beginFunc = fir::runtime::getRuntimeFunc<mkRTKey(CharacterCompareScalar4)>(
loc, builder); loc, builder);
break; break;
default: default:
llvm_unreachable("runtime does not support CHARACTER KIND"); llvm_unreachable("runtime does not support CHARACTER KIND");
} }
auto fTy = beginFunc.getType(); auto fTy = beginFunc.getFunctionType();
auto args = fir::runtime::createArguments(builder, loc, fTy, lhsBuff, rhsBuff, auto args = fir::runtime::createArguments(builder, loc, fTy, lhsBuff, rhsBuff,
lhsLen, rhsLen); lhsLen, rhsLen);
auto tri = builder.create<fir::CallOp>(loc, beginFunc, args).getResult(0); auto tri = builder.create<fir::CallOp>(loc, beginFunc, args).getResult(0);
auto zero = builder.createIntegerConstant(loc, tri.getType(), 0); auto zero = builder.createIntegerConstant(loc, tri.getType(), 0);
return builder.create<mlir::arith::CmpIOp>(loc, cmp, tri, zero); return builder.create<mlir::arith::CmpIOp>(loc, cmp, tri, zero);
} }
mlir::Value fir::runtime::genCharCompare(fir::FirOpBuilder &builder, mlir::Value fir::runtime::genCharCompare(fir::FirOpBuilder &builder,
Show All 33 Lines case 2:
break; break;
case 4: case 4:
indexFunc = fir::runtime::getRuntimeFunc<mkRTKey(Index4)>(loc, builder); indexFunc = fir::runtime::getRuntimeFunc<mkRTKey(Index4)>(loc, builder);
break; break;
default: default:
fir::emitFatalError( fir::emitFatalError(
loc, "unsupported CHARACTER kind value. Runtime expects 1, 2, or 4."); loc, "unsupported CHARACTER kind value. Runtime expects 1, 2, or 4.");
} }
auto fTy = indexFunc.getType(); auto fTy = indexFunc.getFunctionType();
auto args = auto args =
fir::runtime::createArguments(builder, loc, fTy, stringBase, stringLen, fir::runtime::createArguments(builder, loc, fTy, stringBase, stringLen,
substringBase, substringLen, back); substringBase, substringLen, back);
return builder.create<fir::CallOp>(loc, indexFunc, args).getResult(0); return builder.create<fir::CallOp>(loc, indexFunc, args).getResult(0);
} }
void fir::runtime::genIndexDescriptor(fir::FirOpBuilder &builder, void fir::runtime::genIndexDescriptor(fir::FirOpBuilder &builder,
mlir::Location loc, mlir::Value resultBox, mlir::Location loc, mlir::Value resultBox,
mlir::Value stringBox, mlir::Value stringBox,
mlir::Value substringBox, mlir::Value substringBox,
mlir::Value backOpt, mlir::Value kind) { mlir::Value backOpt, mlir::Value kind) {
auto indexFunc = fir::runtime::getRuntimeFunc<mkRTKey(Index)>(loc, builder); auto indexFunc = fir::runtime::getRuntimeFunc<mkRTKey(Index)>(loc, builder);
genCharacterSearch(indexFunc, builder, loc, resultBox, stringBox, genCharacterSearch(indexFunc, builder, loc, resultBox, stringBox,
substringBox, backOpt, kind); substringBox, backOpt, kind);
} }
void fir::runtime::genRepeat(fir::FirOpBuilder &builder, mlir::Location loc, void fir::runtime::genRepeat(fir::FirOpBuilder &builder, mlir::Location loc,
mlir::Value resultBox, mlir::Value stringBox, mlir::Value resultBox, mlir::Value stringBox,
mlir::Value ncopies) { mlir::Value ncopies) {
auto repeatFunc = fir::runtime::getRuntimeFunc<mkRTKey(Repeat)>(loc, builder); auto repeatFunc = fir::runtime::getRuntimeFunc<mkRTKey(Repeat)>(loc, builder);
auto fTy = repeatFunc.getType(); auto fTy = repeatFunc.getFunctionType();
auto sourceFile = fir::factory::locationToFilename(builder, loc); auto sourceFile = fir::factory::locationToFilename(builder, loc);
auto sourceLine = auto sourceLine =
fir::factory::locationToLineNo(builder, loc, fTy.getInput(4)); fir::factory::locationToLineNo(builder, loc, fTy.getInput(4));
auto args = fir::runtime::createArguments( auto args = fir::runtime::createArguments(
builder, loc, fTy, resultBox, stringBox, ncopies, sourceFile, sourceLine); builder, loc, fTy, resultBox, stringBox, ncopies, sourceFile, sourceLine);
builder.create<fir::CallOp>(loc, repeatFunc, args); builder.create<fir::CallOp>(loc, repeatFunc, args);
} }
void fir::runtime::genTrim(fir::FirOpBuilder &builder, mlir::Location loc, void fir::runtime::genTrim(fir::FirOpBuilder &builder, mlir::Location loc,
mlir::Value resultBox, mlir::Value stringBox) { mlir::Value resultBox, mlir::Value stringBox) {
auto trimFunc = fir::runtime::getRuntimeFunc<mkRTKey(Trim)>(loc, builder); auto trimFunc = fir::runtime::getRuntimeFunc<mkRTKey(Trim)>(loc, builder);
auto fTy = trimFunc.getType(); auto fTy = trimFunc.getFunctionType();
auto sourceFile = fir::factory::locationToFilename(builder, loc); auto sourceFile = fir::factory::locationToFilename(builder, loc);
auto sourceLine = auto sourceLine =
fir::factory::locationToLineNo(builder, loc, fTy.getInput(3)); fir::factory::locationToLineNo(builder, loc, fTy.getInput(3));
auto args = fir::runtime::createArguments(builder, loc, fTy, resultBox, auto args = fir::runtime::createArguments(builder, loc, fTy, resultBox,
stringBox, sourceFile, sourceLine); stringBox, sourceFile, sourceLine);
builder.create<fir::CallOp>(loc, trimFunc, args); builder.create<fir::CallOp>(loc, trimFunc, args);
} }
Show All 22 Lines case 2:
break; break;
case 4: case 4:
func = fir::runtime::getRuntimeFunc<mkRTKey(Scan4)>(loc, builder); func = fir::runtime::getRuntimeFunc<mkRTKey(Scan4)>(loc, builder);
break; break;
default: default:
fir::emitFatalError( fir::emitFatalError(
loc, "unsupported CHARACTER kind value. Runtime expects 1, 2, or 4."); loc, "unsupported CHARACTER kind value. Runtime expects 1, 2, or 4.");
} }
auto fTy = func.getType(); auto fTy = func.getFunctionType();
auto args = fir::runtime::createArguments(builder, loc, fTy, stringBase, auto args = fir::runtime::createArguments(builder, loc, fTy, stringBase,
stringLen, setBase, setLen, back); stringLen, setBase, setLen, back);
return builder.create<fir::CallOp>(loc, func, args).getResult(0); return builder.create<fir::CallOp>(loc, func, args).getResult(0);
} }
void fir::runtime::genVerifyDescriptor(fir::FirOpBuilder &builder, void fir::runtime::genVerifyDescriptor(fir::FirOpBuilder &builder,
mlir::Location loc, mlir::Location loc,
mlir::Value resultBox, mlir::Value resultBox,
Show All 20 Lines case 2:
break; break;
case 4: case 4:
func = fir::runtime::getRuntimeFunc<mkRTKey(Verify4)>(loc, builder); func = fir::runtime::getRuntimeFunc<mkRTKey(Verify4)>(loc, builder);
break; break;
default: default:
fir::emitFatalError( fir::emitFatalError(
loc, "unsupported CHARACTER kind value. Runtime expects 1, 2, or 4."); loc, "unsupported CHARACTER kind value. Runtime expects 1, 2, or 4.");
} }
auto fTy = func.getType(); auto fTy = func.getFunctionType();
auto args = fir::runtime::createArguments(builder, loc, fTy, stringBase, auto args = fir::runtime::createArguments(builder, loc, fTy, stringBase,
stringLen, setBase, setLen, back); stringLen, setBase, setLen, back);
return builder.create<fir::CallOp>(loc, func, args).getResult(0); return builder.create<fir::CallOp>(loc, func, args).getResult(0);
} }

flang/lib/Optimizer/Builder/Runtime/Command.cpp

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Linesvoid fir::runtime::genGetCommandArgument(fir::FirOpBuilder &builder,
auto argumentLengthFunc = auto argumentLengthFunc =
fir::runtime::getRuntimeFunc<mkRTKey(ArgumentLength)>(loc, builder); fir::runtime::getRuntimeFunc<mkRTKey(ArgumentLength)>(loc, builder);
mlir::Value valueResult; mlir::Value valueResult;
// Run `ArgumentValue` intrinsic only if we have a "value" in either "VALUE", // Run `ArgumentValue` intrinsic only if we have a "value" in either "VALUE",
// "STATUS" or "ERRMSG" parameters. // "STATUS" or "ERRMSG" parameters.
if (!isAbsent(value) || status || !isAbsent(errmsg)) { if (!isAbsent(value) || status || !isAbsent(errmsg)) {
llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments( llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments(
builder, loc, argumentValueFunc.getType(), number, value, errmsg); builder, loc, argumentValueFunc.getFunctionType(), number, value,
errmsg);
valueResult = valueResult =
builder.create<fir::CallOp>(loc, argumentValueFunc, args).getResult(0); builder.create<fir::CallOp>(loc, argumentValueFunc, args).getResult(0);
} }
// Only save result of `ArgumentValue` if "STATUS" parameter has been given // Only save result of `ArgumentValue` if "STATUS" parameter has been given
if (status) { if (status) {
const mlir::Value statusLoaded = builder.create<fir::LoadOp>(loc, status); const mlir::Value statusLoaded = builder.create<fir::LoadOp>(loc, status);
mlir::Value resultCast = mlir::Value resultCast =
builder.createConvert(loc, statusLoaded.getType(), valueResult); builder.createConvert(loc, statusLoaded.getType(), valueResult);
builder.create<fir::StoreOp>(loc, resultCast, status); builder.create<fir::StoreOp>(loc, resultCast, status);
} }
// Only run `ArgumentLength` intrinsic if "LENGTH" parameter provided // Only run `ArgumentLength` intrinsic if "LENGTH" parameter provided
if (length) { if (length) {
llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments( llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments(
builder, loc, argumentLengthFunc.getType(), number); builder, loc, argumentLengthFunc.getFunctionType(), number);
mlir::Value result = mlir::Value result =
builder.create<fir::CallOp>(loc, argumentLengthFunc, args).getResult(0); builder.create<fir::CallOp>(loc, argumentLengthFunc, args).getResult(0);
const mlir::Value valueLoaded = builder.create<fir::LoadOp>(loc, length); const mlir::Value valueLoaded = builder.create<fir::LoadOp>(loc, length);
mlir::Value resultCast = mlir::Value resultCast =
builder.createConvert(loc, valueLoaded.getType(), result); builder.createConvert(loc, valueLoaded.getType(), result);
builder.create<fir::StoreOp>(loc, resultCast, length); builder.create<fir::StoreOp>(loc, resultCast, length);
} }
} }
Show All 9 Linesvoid fir::runtime::genGetEnvironmentVariable(
mlir::Value sourceFile; mlir::Value sourceFile;
mlir::Value sourceLine; mlir::Value sourceLine;
// We only need `sourceFile` and `sourceLine` variables when calling either // We only need `sourceFile` and `sourceLine` variables when calling either
// `EnvVariableValue` or `EnvVariableLength` below. // `EnvVariableValue` or `EnvVariableLength` below.
if (!isAbsent(value) || status || !isAbsent(errmsg) || length) { if (!isAbsent(value) || status || !isAbsent(errmsg) || length) {
sourceFile = fir::factory::locationToFilename(builder, loc); sourceFile = fir::factory::locationToFilename(builder, loc);
sourceLine = fir::factory::locationToLineNo( sourceLine = fir::factory::locationToLineNo(
builder, loc, valueFunc.getType().getInput(5)); builder, loc, valueFunc.getFunctionType().getInput(5));
} }
mlir::Value valueResult; mlir::Value valueResult;
// Run `EnvVariableValue` intrinsic only if we have a "value" in either // Run `EnvVariableValue` intrinsic only if we have a "value" in either
// "VALUE", "STATUS" or "ERRMSG" parameters. // "VALUE", "STATUS" or "ERRMSG" parameters.
if (!isAbsent(value) || status || !isAbsent(errmsg)) { if (!isAbsent(value) || status || !isAbsent(errmsg)) {
llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments( llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments(
builder, loc, valueFunc.getType(), name, value, trimName, errmsg, builder, loc, valueFunc.getFunctionType(), name, value, trimName,
sourceFile, sourceLine); errmsg, sourceFile, sourceLine);
valueResult = valueResult =
builder.create<fir::CallOp>(loc, valueFunc, args).getResult(0); builder.create<fir::CallOp>(loc, valueFunc, args).getResult(0);
} }
// Only save result of `EnvVariableValue` if "STATUS" parameter provided // Only save result of `EnvVariableValue` if "STATUS" parameter provided
if (status) { if (status) {
const mlir::Value statusLoaded = builder.create<fir::LoadOp>(loc, status); const mlir::Value statusLoaded = builder.create<fir::LoadOp>(loc, status);
mlir::Value resultCast = mlir::Value resultCast =
builder.createConvert(loc, statusLoaded.getType(), valueResult); builder.createConvert(loc, statusLoaded.getType(), valueResult);
builder.create<fir::StoreOp>(loc, resultCast, status); builder.create<fir::StoreOp>(loc, resultCast, status);
} }
// Only run `EnvVariableLength` intrinsic if "LENGTH" parameter provided // Only run `EnvVariableLength` intrinsic if "LENGTH" parameter provided
if (length) { if (length) {
llvm::SmallVector<mlir::Value> args = llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments(
fir::runtime::createArguments(builder, loc, lengthFunc.getType(), name, builder, loc, lengthFunc.getFunctionType(), name, trimName, sourceFile,
trimName, sourceFile, sourceLine); sourceLine);
mlir::Value result = mlir::Value result =
builder.create<fir::CallOp>(loc, lengthFunc, args).getResult(0); builder.create<fir::CallOp>(loc, lengthFunc, args).getResult(0);
const mlir::Value lengthLoaded = builder.create<fir::LoadOp>(loc, length); const mlir::Value lengthLoaded = builder.create<fir::LoadOp>(loc, length);
mlir::Value resultCast = mlir::Value resultCast =
builder.createConvert(loc, lengthLoaded.getType(), result); builder.createConvert(loc, lengthLoaded.getType(), result);
builder.create<fir::StoreOp>(loc, resultCast, length); builder.create<fir::StoreOp>(loc, resultCast, length);
} }
} }

flang/lib/Optimizer/Builder/Runtime/Derived.cpp

Show All 11 Lines
#include "flang/Runtime/derived-api.h" #include "flang/Runtime/derived-api.h"
using namespace Fortran::runtime; using namespace Fortran::runtime;
void fir::runtime::genDerivedTypeInitialize(fir::FirOpBuilder &builder, void fir::runtime::genDerivedTypeInitialize(fir::FirOpBuilder &builder,
mlir::Location loc, mlir::Location loc,
mlir::Value box) { mlir::Value box) {
auto func = fir::runtime::getRuntimeFunc<mkRTKey(Initialize)>(loc, builder); auto func = fir::runtime::getRuntimeFunc<mkRTKey(Initialize)>(loc, builder);
auto fTy = func.getType(); auto fTy = func.getFunctionType();
auto sourceFile = fir::factory::locationToFilename(builder, loc); auto sourceFile = fir::factory::locationToFilename(builder, loc);
auto sourceLine = auto sourceLine =
fir::factory::locationToLineNo(builder, loc, fTy.getInput(2)); fir::factory::locationToLineNo(builder, loc, fTy.getInput(2));
auto args = fir::runtime::createArguments(builder, loc, fTy, box, sourceFile, auto args = fir::runtime::createArguments(builder, loc, fTy, box, sourceFile,
sourceLine); sourceLine);
builder.create<fir::CallOp>(loc, func, args); builder.create<fir::CallOp>(loc, func, args);
} }
void fir::runtime::genDerivedTypeDestroy(fir::FirOpBuilder &builder, void fir::runtime::genDerivedTypeDestroy(fir::FirOpBuilder &builder,
mlir::Location loc, mlir::Value box) { mlir::Location loc, mlir::Value box) {
auto func = fir::runtime::getRuntimeFunc<mkRTKey(Destroy)>(loc, builder); auto func = fir::runtime::getRuntimeFunc<mkRTKey(Destroy)>(loc, builder);
auto fTy = func.getType(); auto fTy = func.getFunctionType();
auto args = fir::runtime::createArguments(builder, loc, fTy, box); auto args = fir::runtime::createArguments(builder, loc, fTy, box);
builder.create<fir::CallOp>(loc, func, args); builder.create<fir::CallOp>(loc, func, args);
} }

flang/lib/Optimizer/Builder/Runtime/Inquiry.cpp

Show All 13 Lines
using namespace Fortran::runtime; using namespace Fortran::runtime;
/// Generate call to `Lbound` runtime routine when the DIM argument is present. /// Generate call to `Lbound` runtime routine when the DIM argument is present.
mlir::Value fir::runtime::genLboundDim(fir::FirOpBuilder &builder, mlir::Value fir::runtime::genLboundDim(fir::FirOpBuilder &builder,
mlir::Location loc, mlir::Value array, mlir::Location loc, mlir::Value array,
mlir::Value dim) { mlir::Value dim) {
mlir::FuncOp lboundFunc = mlir::FuncOp lboundFunc =
fir::runtime::getRuntimeFunc<mkRTKey(LboundDim)>(loc, builder); fir::runtime::getRuntimeFunc<mkRTKey(LboundDim)>(loc, builder);
auto fTy = lboundFunc.getType(); auto fTy = lboundFunc.getFunctionType();
auto sourceFile = fir::factory::locationToFilename(builder, loc); auto sourceFile = fir::factory::locationToFilename(builder, loc);
auto sourceLine = auto sourceLine =
fir::factory::locationToLineNo(builder, loc, fTy.getInput(3)); fir::factory::locationToLineNo(builder, loc, fTy.getInput(3));
auto args = fir::runtime::createArguments(builder, loc, fTy, array, dim, auto args = fir::runtime::createArguments(builder, loc, fTy, array, dim,
sourceFile, sourceLine); sourceFile, sourceLine);
return builder.create<fir::CallOp>(loc, lboundFunc, args).getResult(0); return builder.create<fir::CallOp>(loc, lboundFunc, args).getResult(0);
} }
/// Generate call to `Ubound` runtime routine. Calls to UBOUND with a DIM /// Generate call to `Ubound` runtime routine. Calls to UBOUND with a DIM
/// argument get transformed into an expression equivalent to /// argument get transformed into an expression equivalent to
/// SIZE() + LBOUND() - 1, so they don't have an intrinsic in the runtime. /// SIZE() + LBOUND() - 1, so they don't have an intrinsic in the runtime.
void fir::runtime::genUbound(fir::FirOpBuilder &builder, mlir::Location loc, void fir::runtime::genUbound(fir::FirOpBuilder &builder, mlir::Location loc,
mlir::Value resultBox, mlir::Value array, mlir::Value resultBox, mlir::Value array,
mlir::Value kind) { mlir::Value kind) {
mlir::FuncOp uboundFunc = mlir::FuncOp uboundFunc =
fir::runtime::getRuntimeFunc<mkRTKey(Ubound)>(loc, builder); fir::runtime::getRuntimeFunc<mkRTKey(Ubound)>(loc, builder);
auto fTy = uboundFunc.getType(); auto fTy = uboundFunc.getFunctionType();
auto sourceFile = fir::factory::locationToFilename(builder, loc); auto sourceFile = fir::factory::locationToFilename(builder, loc);
auto sourceLine = auto sourceLine =
fir::factory::locationToLineNo(builder, loc, fTy.getInput(2)); fir::factory::locationToLineNo(builder, loc, fTy.getInput(2));
auto args = fir::runtime::createArguments(builder, loc, fTy, resultBox, array, auto args = fir::runtime::createArguments(builder, loc, fTy, resultBox, array,
kind, sourceFile, sourceLine); kind, sourceFile, sourceLine);
builder.create<fir::CallOp>(loc, uboundFunc, args).getResult(0); builder.create<fir::CallOp>(loc, uboundFunc, args).getResult(0);
} }
/// Generate call to `Size` runtime routine. This routine is a version when /// Generate call to `Size` runtime routine. This routine is a version when
/// the DIM argument is present. /// the DIM argument is present.
mlir::Value fir::runtime::genSizeDim(fir::FirOpBuilder &builder, mlir::Value fir::runtime::genSizeDim(fir::FirOpBuilder &builder,
mlir::Location loc, mlir::Value array, mlir::Location loc, mlir::Value array,
mlir::Value dim) { mlir::Value dim) {
mlir::FuncOp sizeFunc = mlir::FuncOp sizeFunc =
fir::runtime::getRuntimeFunc<mkRTKey(SizeDim)>(loc, builder); fir::runtime::getRuntimeFunc<mkRTKey(SizeDim)>(loc, builder);
auto fTy = sizeFunc.getType(); auto fTy = sizeFunc.getFunctionType();
auto sourceFile = fir::factory::locationToFilename(builder, loc); auto sourceFile = fir::factory::locationToFilename(builder, loc);
auto sourceLine = auto sourceLine =
fir::factory::locationToLineNo(builder, loc, fTy.getInput(3)); fir::factory::locationToLineNo(builder, loc, fTy.getInput(3));
auto args = fir::runtime::createArguments(builder, loc, fTy, array, dim, auto args = fir::runtime::createArguments(builder, loc, fTy, array, dim,
sourceFile, sourceLine); sourceFile, sourceLine);
return builder.create<fir::CallOp>(loc, sizeFunc, args).getResult(0); return builder.create<fir::CallOp>(loc, sizeFunc, args).getResult(0);
} }
/// Generate call to `Size` runtime routine. This routine is a version when /// Generate call to `Size` runtime routine. This routine is a version when
/// the DIM argument is absent. /// the DIM argument is absent.
mlir::Value fir::runtime::genSize(fir::FirOpBuilder &builder, mlir::Value fir::runtime::genSize(fir::FirOpBuilder &builder,
mlir::Location loc, mlir::Value array) { mlir::Location loc, mlir::Value array) {
mlir::FuncOp sizeFunc = mlir::FuncOp sizeFunc =
fir::runtime::getRuntimeFunc<mkRTKey(Size)>(loc, builder); fir::runtime::getRuntimeFunc<mkRTKey(Size)>(loc, builder);
auto fTy = sizeFunc.getType(); auto fTy = sizeFunc.getFunctionType();
auto sourceFile = fir::factory::locationToFilename(builder, loc); auto sourceFile = fir::factory::locationToFilename(builder, loc);
auto sourceLine = auto sourceLine =
fir::factory::locationToLineNo(builder, loc, fTy.getInput(2)); fir::factory::locationToLineNo(builder, loc, fTy.getInput(2));
auto args = fir::runtime::createArguments(builder, loc, fTy, array, auto args = fir::runtime::createArguments(builder, loc, fTy, array,
sourceFile, sourceLine); sourceFile, sourceLine);
return builder.create<fir::CallOp>(loc, sizeFunc, args).getResult(0); return builder.create<fir::CallOp>(loc, sizeFunc, args).getResult(0);
} }

flang/lib/Optimizer/Builder/Runtime/Numeric.cpp

Show First 20 Lines • Show All 229 Lines • ▼ Show 20 Linesmlir::Value fir::runtime::genExponent(fir::FirOpBuilder &builder,
} else if (fltTy.isF128()) { } else if (fltTy.isF128()) {
if (resultType.isInteger(32)) if (resultType.isInteger(32))
func = fir::runtime::getRuntimeFunc<ForcedExponent16_4>(loc, builder); func = fir::runtime::getRuntimeFunc<ForcedExponent16_4>(loc, builder);
else if (resultType.isInteger(64)) else if (resultType.isInteger(64))
func = fir::runtime::getRuntimeFunc<ForcedExponent16_8>(loc, builder); func = fir::runtime::getRuntimeFunc<ForcedExponent16_8>(loc, builder);
} else } else
fir::emitFatalError(loc, "unsupported real kind in Exponent lowering"); fir::emitFatalError(loc, "unsupported real kind in Exponent lowering");
auto funcTy = func.getType(); auto funcTy = func.getFunctionType();
llvm::SmallVector<mlir::Value> args = { llvm::SmallVector<mlir::Value> args = {
builder.createConvert(loc, funcTy.getInput(0), x)}; builder.createConvert(loc, funcTy.getInput(0), x)};
return builder.create<fir::CallOp>(loc, func, args).getResult(0); return builder.create<fir::CallOp>(loc, func, args).getResult(0);
} }
/// Generate call to Fraction instrinsic runtime routine. /// Generate call to Fraction instrinsic runtime routine.
mlir::Value fir::runtime::genFraction(fir::FirOpBuilder &builder, mlir::Value fir::runtime::genFraction(fir::FirOpBuilder &builder,
mlir::Location loc, mlir::Value x) { mlir::Location loc, mlir::Value x) {
mlir::FuncOp func; mlir::FuncOp func;
mlir::Type fltTy = x.getType(); mlir::Type fltTy = x.getType();
if (fltTy.isF32()) if (fltTy.isF32())
func = fir::runtime::getRuntimeFunc<mkRTKey(Fraction4)>(loc, builder); func = fir::runtime::getRuntimeFunc<mkRTKey(Fraction4)>(loc, builder);
else if (fltTy.isF64()) else if (fltTy.isF64())
func = fir::runtime::getRuntimeFunc<mkRTKey(Fraction8)>(loc, builder); func = fir::runtime::getRuntimeFunc<mkRTKey(Fraction8)>(loc, builder);
else if (fltTy.isF80()) else if (fltTy.isF80())
func = fir::runtime::getRuntimeFunc<ForcedFraction10>(loc, builder); func = fir::runtime::getRuntimeFunc<ForcedFraction10>(loc, builder);
else if (fltTy.isF128()) else if (fltTy.isF128())
func = fir::runtime::getRuntimeFunc<ForcedFraction16>(loc, builder); func = fir::runtime::getRuntimeFunc<ForcedFraction16>(loc, builder);
else else
fir::emitFatalError(loc, "unsupported real kind in Fraction lowering"); fir::emitFatalError(loc, "unsupported real kind in Fraction lowering");
auto funcTy = func.getType(); auto funcTy = func.getFunctionType();
llvm::SmallVector<mlir::Value> args = { llvm::SmallVector<mlir::Value> args = {
builder.createConvert(loc, funcTy.getInput(0), x)}; builder.createConvert(loc, funcTy.getInput(0), x)};
return builder.create<fir::CallOp>(loc, func, args).getResult(0); return builder.create<fir::CallOp>(loc, func, args).getResult(0);
} }
/// Generate call to Nearest intrinsic runtime routine. /// Generate call to Nearest intrinsic runtime routine.
mlir::Value fir::runtime::genNearest(fir::FirOpBuilder &builder, mlir::Value fir::runtime::genNearest(fir::FirOpBuilder &builder,
mlir::Location loc, mlir::Value x, mlir::Location loc, mlir::Value x,
mlir::Value s) { mlir::Value s) {
mlir::FuncOp func; mlir::FuncOp func;
mlir::Type fltTy = x.getType(); mlir::Type fltTy = x.getType();
if (fltTy.isF32()) if (fltTy.isF32())
func = fir::runtime::getRuntimeFunc<mkRTKey(Nearest4)>(loc, builder); func = fir::runtime::getRuntimeFunc<mkRTKey(Nearest4)>(loc, builder);
else if (fltTy.isF64()) else if (fltTy.isF64())
func = fir::runtime::getRuntimeFunc<mkRTKey(Nearest8)>(loc, builder); func = fir::runtime::getRuntimeFunc<mkRTKey(Nearest8)>(loc, builder);
else if (fltTy.isF80()) else if (fltTy.isF80())
func = fir::runtime::getRuntimeFunc<ForcedNearest10>(loc, builder); func = fir::runtime::getRuntimeFunc<ForcedNearest10>(loc, builder);
else if (fltTy.isF128()) else if (fltTy.isF128())
func = fir::runtime::getRuntimeFunc<ForcedNearest16>(loc, builder); func = fir::runtime::getRuntimeFunc<ForcedNearest16>(loc, builder);
else else
fir::emitFatalError(loc, "unsupported REAL kind in Nearest lowering"); fir::emitFatalError(loc, "unsupported REAL kind in Nearest lowering");
auto funcTy = func.getType(); auto funcTy = func.getFunctionType();
mlir::Type sTy = s.getType(); mlir::Type sTy = s.getType();
mlir::Value zero = builder.createRealZeroConstant(loc, sTy); mlir::Value zero = builder.createRealZeroConstant(loc, sTy);
auto cmp = builder.create<mlir::arith::CmpFOp>( auto cmp = builder.create<mlir::arith::CmpFOp>(
loc, mlir::arith::CmpFPredicate::OGT, s, zero); loc, mlir::arith::CmpFPredicate::OGT, s, zero);
mlir::Type boolTy = mlir::IntegerType::get(builder.getContext(), 1); mlir::Type boolTy = mlir::IntegerType::get(builder.getContext(), 1);
mlir::Value False = builder.createIntegerConstant(loc, boolTy, 0); mlir::Value False = builder.createIntegerConstant(loc, boolTy, 0);
Show All 18 Lines else if (fltTy.isF64())
func = fir::runtime::getRuntimeFunc<mkRTKey(RRSpacing8)>(loc, builder); func = fir::runtime::getRuntimeFunc<mkRTKey(RRSpacing8)>(loc, builder);
else if (fltTy.isF80()) else if (fltTy.isF80())
func = fir::runtime::getRuntimeFunc<ForcedRRSpacing10>(loc, builder); func = fir::runtime::getRuntimeFunc<ForcedRRSpacing10>(loc, builder);
else if (fltTy.isF128()) else if (fltTy.isF128())
func = fir::runtime::getRuntimeFunc<ForcedRRSpacing16>(loc, builder); func = fir::runtime::getRuntimeFunc<ForcedRRSpacing16>(loc, builder);
else else
fir::emitFatalError(loc, "unsupported real kind in RRSpacing lowering"); fir::emitFatalError(loc, "unsupported real kind in RRSpacing lowering");
auto funcTy = func.getType(); auto funcTy = func.getFunctionType();
llvm::SmallVector<mlir::Value> args = { llvm::SmallVector<mlir::Value> args = {
builder.createConvert(loc, funcTy.getInput(0), x)}; builder.createConvert(loc, funcTy.getInput(0), x)};
return builder.create<fir::CallOp>(loc, func, args).getResult(0); return builder.create<fir::CallOp>(loc, func, args).getResult(0);
} }
/// Generate call to Scale intrinsic runtime routine. /// Generate call to Scale intrinsic runtime routine.
mlir::Value fir::runtime::genScale(fir::FirOpBuilder &builder, mlir::Value fir::runtime::genScale(fir::FirOpBuilder &builder,
mlir::Location loc, mlir::Value x, mlir::Location loc, mlir::Value x,
mlir::Value i) { mlir::Value i) {
mlir::FuncOp func; mlir::FuncOp func;
mlir::Type fltTy = x.getType(); mlir::Type fltTy = x.getType();
if (fltTy.isF32()) if (fltTy.isF32())
func = fir::runtime::getRuntimeFunc<mkRTKey(Scale4)>(loc, builder); func = fir::runtime::getRuntimeFunc<mkRTKey(Scale4)>(loc, builder);
else if (fltTy.isF64()) else if (fltTy.isF64())
func = fir::runtime::getRuntimeFunc<mkRTKey(Scale8)>(loc, builder); func = fir::runtime::getRuntimeFunc<mkRTKey(Scale8)>(loc, builder);
else if (fltTy.isF80()) else if (fltTy.isF80())
func = fir::runtime::getRuntimeFunc<ForcedScale10>(loc, builder); func = fir::runtime::getRuntimeFunc<ForcedScale10>(loc, builder);
else if (fltTy.isF128()) else if (fltTy.isF128())
func = fir::runtime::getRuntimeFunc<ForcedScale16>(loc, builder); func = fir::runtime::getRuntimeFunc<ForcedScale16>(loc, builder);
else else
fir::emitFatalError(loc, "unsupported REAL kind in Scale lowering"); fir::emitFatalError(loc, "unsupported REAL kind in Scale lowering");
auto funcTy = func.getType(); auto funcTy = func.getFunctionType();
auto args = fir::runtime::createArguments(builder, loc, funcTy, x, i); auto args = fir::runtime::createArguments(builder, loc, funcTy, x, i);
return builder.create<fir::CallOp>(loc, func, args).getResult(0); return builder.create<fir::CallOp>(loc, func, args).getResult(0);
} }
/// Generate call to Set_exponent instrinsic runtime routine. /// Generate call to Set_exponent instrinsic runtime routine.
mlir::Value fir::runtime::genSetExponent(fir::FirOpBuilder &builder, mlir::Value fir::runtime::genSetExponent(fir::FirOpBuilder &builder,
mlir::Location loc, mlir::Value x, mlir::Location loc, mlir::Value x,
mlir::Value i) { mlir::Value i) {
mlir::FuncOp func; mlir::FuncOp func;
mlir::Type fltTy = x.getType(); mlir::Type fltTy = x.getType();
if (fltTy.isF32()) if (fltTy.isF32())
func = fir::runtime::getRuntimeFunc<mkRTKey(SetExponent4)>(loc, builder); func = fir::runtime::getRuntimeFunc<mkRTKey(SetExponent4)>(loc, builder);
else if (fltTy.isF64()) else if (fltTy.isF64())
func = fir::runtime::getRuntimeFunc<mkRTKey(SetExponent8)>(loc, builder); func = fir::runtime::getRuntimeFunc<mkRTKey(SetExponent8)>(loc, builder);
else if (fltTy.isF80()) else if (fltTy.isF80())
func = fir::runtime::getRuntimeFunc<ForcedSetExponent10>(loc, builder); func = fir::runtime::getRuntimeFunc<ForcedSetExponent10>(loc, builder);
else if (fltTy.isF128()) else if (fltTy.isF128())
func = fir::runtime::getRuntimeFunc<ForcedSetExponent16>(loc, builder); func = fir::runtime::getRuntimeFunc<ForcedSetExponent16>(loc, builder);
else else
fir::emitFatalError(loc, "unsupported real kind in Fraction lowering"); fir::emitFatalError(loc, "unsupported real kind in Fraction lowering");
auto funcTy = func.getType(); auto funcTy = func.getFunctionType();
auto args = fir::runtime::createArguments(builder, loc, funcTy, x, i); auto args = fir::runtime::createArguments(builder, loc, funcTy, x, i);
return builder.create<fir::CallOp>(loc, func, args).getResult(0); return builder.create<fir::CallOp>(loc, func, args).getResult(0);
} }
/// Generate call to Spacing intrinsic runtime routine. /// Generate call to Spacing intrinsic runtime routine.
mlir::Value fir::runtime::genSpacing(fir::FirOpBuilder &builder, mlir::Value fir::runtime::genSpacing(fir::FirOpBuilder &builder,
mlir::Location loc, mlir::Value x) { mlir::Location loc, mlir::Value x) {
mlir::FuncOp func; mlir::FuncOp func;
mlir::Type fltTy = x.getType(); mlir::Type fltTy = x.getType();
if (fltTy.isF32()) if (fltTy.isF32())
func = fir::runtime::getRuntimeFunc<mkRTKey(Spacing4)>(loc, builder); func = fir::runtime::getRuntimeFunc<mkRTKey(Spacing4)>(loc, builder);
else if (fltTy.isF64()) else if (fltTy.isF64())
func = fir::runtime::getRuntimeFunc<mkRTKey(Spacing8)>(loc, builder); func = fir::runtime::getRuntimeFunc<mkRTKey(Spacing8)>(loc, builder);
else if (fltTy.isF80()) else if (fltTy.isF80())
func = fir::runtime::getRuntimeFunc<ForcedSpacing10>(loc, builder); func = fir::runtime::getRuntimeFunc<ForcedSpacing10>(loc, builder);
else if (fltTy.isF128()) else if (fltTy.isF128())
func = fir::runtime::getRuntimeFunc<ForcedSpacing16>(loc, builder); func = fir::runtime::getRuntimeFunc<ForcedSpacing16>(loc, builder);
else else
fir::emitFatalError(loc, "unsupported real kind in Spacing lowering"); fir::emitFatalError(loc, "unsupported real kind in Spacing lowering");
auto funcTy = func.getType(); auto funcTy = func.getFunctionType();
llvm::SmallVector<mlir::Value> args = { llvm::SmallVector<mlir::Value> args = {
builder.createConvert(loc, funcTy.getInput(0), x)}; builder.createConvert(loc, funcTy.getInput(0), x)};
return builder.create<fir::CallOp>(loc, func, args).getResult(0); return builder.create<fir::CallOp>(loc, func, args).getResult(0);
} }

flang/lib/Optimizer/Builder/Runtime/Ragged.cpp

Show All 17 Linesvoid fir::runtime::genRaggedArrayAllocate(mlir::Location loc,
mlir::Value header, bool asHeaders, mlir::Value header, bool asHeaders,
mlir::Value eleSize, mlir::Value eleSize,
mlir::ValueRange extents) { mlir::ValueRange extents) {
auto i32Ty = builder.getIntegerType(32); auto i32Ty = builder.getIntegerType(32);
auto rank = extents.size(); auto rank = extents.size();
auto i64Ty = builder.getIntegerType(64); auto i64Ty = builder.getIntegerType(64);
auto func = auto func =
fir::runtime::getRuntimeFunc<mkRTKey(RaggedArrayAllocate)>(loc, builder); fir::runtime::getRuntimeFunc<mkRTKey(RaggedArrayAllocate)>(loc, builder);
auto fTy = func.getType(); auto fTy = func.getFunctionType();
auto i1Ty = builder.getIntegerType(1); auto i1Ty = builder.getIntegerType(1);
fir::SequenceType::Shape shape = { fir::SequenceType::Shape shape = {
static_cast<fir::SequenceType::Extent>(rank)}; static_cast<fir::SequenceType::Extent>(rank)};
auto extentTy = fir::SequenceType::get(shape, i64Ty); auto extentTy = fir::SequenceType::get(shape, i64Ty);
auto refTy = fir::ReferenceType::get(i64Ty); auto refTy = fir::ReferenceType::get(i64Ty);
// Position of the bufferPointer in the header struct. // Position of the bufferPointer in the header struct.
auto one = builder.createIntegerConstant(loc, i32Ty, 1); auto one = builder.createIntegerConstant(loc, i32Ty, 1);
auto eleTy = fir::unwrapSequenceType(fir::unwrapRefType(header.getType())); auto eleTy = fir::unwrapSequenceType(fir::unwrapRefType(header.getType()));
Show All 21 Lines builder.genIfThen(loc, cmp)
.end(); .end();
} }
void fir::runtime::genRaggedArrayDeallocate(mlir::Location loc, void fir::runtime::genRaggedArrayDeallocate(mlir::Location loc,
fir::FirOpBuilder &builder, fir::FirOpBuilder &builder,
mlir::Value header) { mlir::Value header) {
auto func = fir::runtime::getRuntimeFunc<mkRTKey(RaggedArrayDeallocate)>( auto func = fir::runtime::getRuntimeFunc<mkRTKey(RaggedArrayDeallocate)>(
loc, builder); loc, builder);
auto fTy = func.getType(); auto fTy = func.getFunctionType();
auto args = fir::runtime::createArguments(builder, loc, fTy, header); auto args = fir::runtime::createArguments(builder, loc, fTy, header);
builder.create<fir::CallOp>(loc, func, args); builder.create<fir::CallOp>(loc, func, args);
} }

flang/lib/Optimizer/Builder/Runtime/Reduction.cpp

Show First 20 Lines • Show All 368 Lines • ▼ Show 20 Lines
}; };
/// Generate call to specialized runtime function that takes a mask and /// Generate call to specialized runtime function that takes a mask and
/// dim argument. The All, Any, and Count intrinsics use this pattern. /// dim argument. The All, Any, and Count intrinsics use this pattern.
template <typename FN> template <typename FN>
mlir::Value genSpecial2Args(FN func, fir::FirOpBuilder &builder, mlir::Value genSpecial2Args(FN func, fir::FirOpBuilder &builder,
mlir::Location loc, mlir::Value maskBox, mlir::Location loc, mlir::Value maskBox,
mlir::Value dim) { mlir::Value dim) {
auto fTy = func.getType(); auto fTy = func.getFunctionType();
auto sourceFile = fir::factory::locationToFilename(builder, loc); auto sourceFile = fir::factory::locationToFilename(builder, loc);
auto sourceLine = auto sourceLine =
fir::factory::locationToLineNo(builder, loc, fTy.getInput(2)); fir::factory::locationToLineNo(builder, loc, fTy.getInput(2));
auto args = fir::runtime::createArguments(builder, loc, fTy, maskBox, auto args = fir::runtime::createArguments(builder, loc, fTy, maskBox,
sourceFile, sourceLine, dim); sourceFile, sourceLine, dim);
return builder.create<fir::CallOp>(loc, func, args).getResult(0); return builder.create<fir::CallOp>(loc, func, args).getResult(0);
} }
/// Generate calls to reduction intrinsics such as All and Any. /// Generate calls to reduction intrinsics such as All and Any.
/// These are the descriptor based implementations that take two /// These are the descriptor based implementations that take two
/// arguments (mask, dim). /// arguments (mask, dim).
template <typename FN> template <typename FN>
static void genReduction2Args(FN func, fir::FirOpBuilder &builder, static void genReduction2Args(FN func, fir::FirOpBuilder &builder,
mlir::Location loc, mlir::Value resultBox, mlir::Location loc, mlir::Value resultBox,
mlir::Value maskBox, mlir::Value dim) { mlir::Value maskBox, mlir::Value dim) {
auto fTy = func.getType(); auto fTy = func.getFunctionType();
auto sourceFile = fir::factory::locationToFilename(builder, loc); auto sourceFile = fir::factory::locationToFilename(builder, loc);
auto sourceLine = auto sourceLine =
fir::factory::locationToLineNo(builder, loc, fTy.getInput(4)); fir::factory::locationToLineNo(builder, loc, fTy.getInput(4));
auto args = fir::runtime::createArguments( auto args = fir::runtime::createArguments(
builder, loc, fTy, resultBox, maskBox, dim, sourceFile, sourceLine); builder, loc, fTy, resultBox, maskBox, dim, sourceFile, sourceLine);
builder.create<fir::CallOp>(loc, func, args); builder.create<fir::CallOp>(loc, func, args);
} }
/// Generate calls to reduction intrinsics such as Maxval and Minval. /// Generate calls to reduction intrinsics such as Maxval and Minval.
/// These take arguments such as (array, dim, mask). /// These take arguments such as (array, dim, mask).
template <typename FN> template <typename FN>
static void genReduction3Args(FN func, fir::FirOpBuilder &builder, static void genReduction3Args(FN func, fir::FirOpBuilder &builder,
mlir::Location loc, mlir::Value resultBox, mlir::Location loc, mlir::Value resultBox,
mlir::Value arrayBox, mlir::Value dim, mlir::Value arrayBox, mlir::Value dim,
mlir::Value maskBox) { mlir::Value maskBox) {
auto fTy = func.getType(); auto fTy = func.getFunctionType();
auto sourceFile = fir::factory::locationToFilename(builder, loc); auto sourceFile = fir::factory::locationToFilename(builder, loc);
auto sourceLine = auto sourceLine =
fir::factory::locationToLineNo(builder, loc, fTy.getInput(4)); fir::factory::locationToLineNo(builder, loc, fTy.getInput(4));
auto args = auto args =
fir::runtime::createArguments(builder, loc, fTy, resultBox, arrayBox, dim, fir::runtime::createArguments(builder, loc, fTy, resultBox, arrayBox, dim,
sourceFile, sourceLine, maskBox); sourceFile, sourceLine, maskBox);
builder.create<fir::CallOp>(loc, func, args); builder.create<fir::CallOp>(loc, func, args);
} }
/// Generate calls to reduction intrinsics such as Maxloc and Minloc. /// Generate calls to reduction intrinsics such as Maxloc and Minloc.
/// These take arguments such as (array, mask, kind, back). /// These take arguments such as (array, mask, kind, back).
template <typename FN> template <typename FN>
static void genReduction4Args(FN func, fir::FirOpBuilder &builder, static void genReduction4Args(FN func, fir::FirOpBuilder &builder,
mlir::Location loc, mlir::Value resultBox, mlir::Location loc, mlir::Value resultBox,
mlir::Value arrayBox, mlir::Value maskBox, mlir::Value arrayBox, mlir::Value maskBox,
mlir::Value kind, mlir::Value back) { mlir::Value kind, mlir::Value back) {
auto fTy = func.getType(); auto fTy = func.getFunctionType();
auto sourceFile = fir::factory::locationToFilename(builder, loc); auto sourceFile = fir::factory::locationToFilename(builder, loc);
auto sourceLine = auto sourceLine =
fir::factory::locationToLineNo(builder, loc, fTy.getInput(4)); fir::factory::locationToLineNo(builder, loc, fTy.getInput(4));
auto args = fir::runtime::createArguments(builder, loc, fTy, resultBox, auto args = fir::runtime::createArguments(builder, loc, fTy, resultBox,
arrayBox, kind, sourceFile, arrayBox, kind, sourceFile,
sourceLine, maskBox, back); sourceLine, maskBox, back);
builder.create<fir::CallOp>(loc, func, args); builder.create<fir::CallOp>(loc, func, args);
} }
/// Generate calls to reduction intrinsics such as Maxloc and Minloc. /// Generate calls to reduction intrinsics such as Maxloc and Minloc.
/// These take arguments such as (array, dim, mask, kind, back). /// These take arguments such as (array, dim, mask, kind, back).
template <typename FN> template <typename FN>
static void static void
genReduction5Args(FN func, fir::FirOpBuilder &builder, mlir::Location loc, genReduction5Args(FN func, fir::FirOpBuilder &builder, mlir::Location loc,
mlir::Value resultBox, mlir::Value arrayBox, mlir::Value dim, mlir::Value resultBox, mlir::Value arrayBox, mlir::Value dim,
mlir::Value maskBox, mlir::Value kind, mlir::Value back) { mlir::Value maskBox, mlir::Value kind, mlir::Value back) {
auto fTy = func.getType(); auto fTy = func.getFunctionType();
auto sourceFile = fir::factory::locationToFilename(builder, loc); auto sourceFile = fir::factory::locationToFilename(builder, loc);
auto sourceLine = auto sourceLine =
fir::factory::locationToLineNo(builder, loc, fTy.getInput(5)); fir::factory::locationToLineNo(builder, loc, fTy.getInput(5));
auto args = fir::runtime::createArguments(builder, loc, fTy, resultBox, auto args = fir::runtime::createArguments(builder, loc, fTy, resultBox,
arrayBox, kind, dim, sourceFile, arrayBox, kind, dim, sourceFile,
sourceLine, maskBox, back); sourceLine, maskBox, back);
builder.create<fir::CallOp>(loc, func, args); builder.create<fir::CallOp>(loc, func, args);
} }
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
} }
/// Generate call to general `CountDim` runtime routine. This routine has a /// Generate call to general `CountDim` runtime routine. This routine has a
/// descriptor result. /// descriptor result.
void fir::runtime::genCountDim(fir::FirOpBuilder &builder, mlir::Location loc, void fir::runtime::genCountDim(fir::FirOpBuilder &builder, mlir::Location loc,
mlir::Value resultBox, mlir::Value maskBox, mlir::Value resultBox, mlir::Value maskBox,
mlir::Value dim, mlir::Value kind) { mlir::Value dim, mlir::Value kind) {
auto func = fir::runtime::getRuntimeFunc<mkRTKey(CountDim)>(loc, builder); auto func = fir::runtime::getRuntimeFunc<mkRTKey(CountDim)>(loc, builder);
auto fTy = func.getType(); auto fTy = func.getFunctionType();
auto sourceFile = fir::factory::locationToFilename(builder, loc); auto sourceFile = fir::factory::locationToFilename(builder, loc);
auto sourceLine = auto sourceLine =
fir::factory::locationToLineNo(builder, loc, fTy.getInput(5)); fir::factory::locationToLineNo(builder, loc, fTy.getInput(5));
auto args = fir::runtime::createArguments( auto args = fir::runtime::createArguments(
builder, loc, fTy, resultBox, maskBox, dim, kind, sourceFile, sourceLine); builder, loc, fTy, resultBox, maskBox, dim, kind, sourceFile, sourceLine);
builder.create<fir::CallOp>(loc, func, args); builder.create<fir::CallOp>(loc, func, args);
} }
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Lines else if (eleTy ==
builder.getIntegerType(builder.getKindMap().getIntegerBitsize(8))) builder.getIntegerType(builder.getKindMap().getIntegerBitsize(8)))
func = fir::runtime::getRuntimeFunc<mkRTKey(MaxvalInteger8)>(loc, builder); func = fir::runtime::getRuntimeFunc<mkRTKey(MaxvalInteger8)>(loc, builder);
else if (eleTy == else if (eleTy ==
builder.getIntegerType(builder.getKindMap().getIntegerBitsize(16))) builder.getIntegerType(builder.getKindMap().getIntegerBitsize(16)))
func = fir::runtime::getRuntimeFunc<ForcedMaxvalInteger16>(loc, builder); func = fir::runtime::getRuntimeFunc<ForcedMaxvalInteger16>(loc, builder);
else else
fir::emitFatalError(loc, "invalid type in Maxval lowering"); fir::emitFatalError(loc, "invalid type in Maxval lowering");
auto fTy = func.getType(); auto fTy = func.getFunctionType();
auto sourceFile = fir::factory::locationToFilename(builder, loc); auto sourceFile = fir::factory::locationToFilename(builder, loc);
auto sourceLine = auto sourceLine =
fir::factory::locationToLineNo(builder, loc, fTy.getInput(2)); fir::factory::locationToLineNo(builder, loc, fTy.getInput(2));
auto args = fir::runtime::createArguments( auto args = fir::runtime::createArguments(
builder, loc, fTy, arrayBox, sourceFile, sourceLine, dim, maskBox); builder, loc, fTy, arrayBox, sourceFile, sourceLine, dim, maskBox);
return builder.create<fir::CallOp>(loc, func, args).getResult(0); return builder.create<fir::CallOp>(loc, func, args).getResult(0);
} }
Show All 9 Lines
/// Generate call to `MaxvalCharacter` intrinsic runtime routine. This is the /// Generate call to `MaxvalCharacter` intrinsic runtime routine. This is the
/// version that handles character arrays of rank 1 and without a DIM argument. /// version that handles character arrays of rank 1 and without a DIM argument.
void fir::runtime::genMaxvalChar(fir::FirOpBuilder &builder, mlir::Location loc, void fir::runtime::genMaxvalChar(fir::FirOpBuilder &builder, mlir::Location loc,
mlir::Value resultBox, mlir::Value arrayBox, mlir::Value resultBox, mlir::Value arrayBox,
mlir::Value maskBox) { mlir::Value maskBox) {
auto func = auto func =
fir::runtime::getRuntimeFunc<mkRTKey(MaxvalCharacter)>(loc, builder); fir::runtime::getRuntimeFunc<mkRTKey(MaxvalCharacter)>(loc, builder);
auto fTy = func.getType(); auto fTy = func.getFunctionType();
auto sourceFile = fir::factory::locationToFilename(builder, loc); auto sourceFile = fir::factory::locationToFilename(builder, loc);
auto sourceLine = auto sourceLine =
fir::factory::locationToLineNo(builder, loc, fTy.getInput(3)); fir::factory::locationToLineNo(builder, loc, fTy.getInput(3));
auto args = fir::runtime::createArguments( auto args = fir::runtime::createArguments(
builder, loc, fTy, resultBox, arrayBox, sourceFile, sourceLine, maskBox); builder, loc, fTy, resultBox, arrayBox, sourceFile, sourceLine, maskBox);
builder.create<fir::CallOp>(loc, func, args); builder.create<fir::CallOp>(loc, func, args);
} }
Show All 30 Lines
/// Generate call to `MinvalCharacter` intrinsic runtime routine. This is the /// Generate call to `MinvalCharacter` intrinsic runtime routine. This is the
/// version that handles character arrays of rank 1 and without a DIM argument. /// version that handles character arrays of rank 1 and without a DIM argument.
void fir::runtime::genMinvalChar(fir::FirOpBuilder &builder, mlir::Location loc, void fir::runtime::genMinvalChar(fir::FirOpBuilder &builder, mlir::Location loc,
mlir::Value resultBox, mlir::Value arrayBox, mlir::Value resultBox, mlir::Value arrayBox,
mlir::Value maskBox) { mlir::Value maskBox) {
auto func = auto func =
fir::runtime::getRuntimeFunc<mkRTKey(MinvalCharacter)>(loc, builder); fir::runtime::getRuntimeFunc<mkRTKey(MinvalCharacter)>(loc, builder);
auto fTy = func.getType(); auto fTy = func.getFunctionType();
auto sourceFile = fir::factory::locationToFilename(builder, loc); auto sourceFile = fir::factory::locationToFilename(builder, loc);
auto sourceLine = auto sourceLine =
fir::factory::locationToLineNo(builder, loc, fTy.getInput(3)); fir::factory::locationToLineNo(builder, loc, fTy.getInput(3));
auto args = fir::runtime::createArguments( auto args = fir::runtime::createArguments(
builder, loc, fTy, resultBox, arrayBox, sourceFile, sourceLine, maskBox); builder, loc, fTy, resultBox, arrayBox, sourceFile, sourceLine, maskBox);
builder.create<fir::CallOp>(loc, func, args); builder.create<fir::CallOp>(loc, func, args);
} }
Show All 29 Lines else if (eleTy ==
builder.getIntegerType(builder.getKindMap().getIntegerBitsize(8))) builder.getIntegerType(builder.getKindMap().getIntegerBitsize(8)))
func = fir::runtime::getRuntimeFunc<mkRTKey(MinvalInteger8)>(loc, builder); func = fir::runtime::getRuntimeFunc<mkRTKey(MinvalInteger8)>(loc, builder);
else if (eleTy == else if (eleTy ==
builder.getIntegerType(builder.getKindMap().getIntegerBitsize(16))) builder.getIntegerType(builder.getKindMap().getIntegerBitsize(16)))
func = fir::runtime::getRuntimeFunc<ForcedMinvalInteger16>(loc, builder); func = fir::runtime::getRuntimeFunc<ForcedMinvalInteger16>(loc, builder);
else else
fir::emitFatalError(loc, "invalid type in Minval lowering"); fir::emitFatalError(loc, "invalid type in Minval lowering");
auto fTy = func.getType(); auto fTy = func.getFunctionType();
auto sourceFile = fir::factory::locationToFilename(builder, loc); auto sourceFile = fir::factory::locationToFilename(builder, loc);
auto sourceLine = auto sourceLine =
fir::factory::locationToLineNo(builder, loc, fTy.getInput(2)); fir::factory::locationToLineNo(builder, loc, fTy.getInput(2));
auto args = fir::runtime::createArguments( auto args = fir::runtime::createArguments(
builder, loc, fTy, arrayBox, sourceFile, sourceLine, dim, maskBox); builder, loc, fTy, arrayBox, sourceFile, sourceLine, dim, maskBox);
return builder.create<fir::CallOp>(loc, func, args).getResult(0); return builder.create<fir::CallOp>(loc, func, args).getResult(0);
} }
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Lines func =
fir::runtime::getRuntimeFunc<mkRTKey(CppProductComplex8)>(loc, builder); fir::runtime::getRuntimeFunc<mkRTKey(CppProductComplex8)>(loc, builder);
else if (eleTy == fir::ComplexType::get(builder.getContext(), 10)) else if (eleTy == fir::ComplexType::get(builder.getContext(), 10))
func = fir::runtime::getRuntimeFunc<ForcedProductComplex10>(loc, builder); func = fir::runtime::getRuntimeFunc<ForcedProductComplex10>(loc, builder);
else if (eleTy == fir::ComplexType::get(builder.getContext(), 16)) else if (eleTy == fir::ComplexType::get(builder.getContext(), 16))
func = fir::runtime::getRuntimeFunc<ForcedProductComplex16>(loc, builder); func = fir::runtime::getRuntimeFunc<ForcedProductComplex16>(loc, builder);
else else
fir::emitFatalError(loc, "invalid type in Product lowering"); fir::emitFatalError(loc, "invalid type in Product lowering");
auto fTy = func.getType(); auto fTy = func.getFunctionType();
auto sourceFile = fir::factory::locationToFilename(builder, loc); auto sourceFile = fir::factory::locationToFilename(builder, loc);
if (fir::isa_complex(eleTy)) { if (fir::isa_complex(eleTy)) {
auto sourceLine = auto sourceLine =
fir::factory::locationToLineNo(builder, loc, fTy.getInput(3)); fir::factory::locationToLineNo(builder, loc, fTy.getInput(3));
auto args = auto args =
fir::runtime::createArguments(builder, loc, fTy, resultBox, arrayBox, fir::runtime::createArguments(builder, loc, fTy, resultBox, arrayBox,
sourceFile, sourceLine, dim, maskBox); sourceFile, sourceLine, dim, maskBox);
builder.create<fir::CallOp>(loc, func, args); builder.create<fir::CallOp>(loc, func, args);
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Lines else if (eleTy ==
func = func =
fir::runtime::getRuntimeFunc<ForcedDotProductInteger16>(loc, builder); fir::runtime::getRuntimeFunc<ForcedDotProductInteger16>(loc, builder);
else if (eleTy.isa<fir::LogicalType>()) else if (eleTy.isa<fir::LogicalType>())
func = func =
fir::runtime::getRuntimeFunc<mkRTKey(DotProductLogical)>(loc, builder); fir::runtime::getRuntimeFunc<mkRTKey(DotProductLogical)>(loc, builder);
else else
fir::emitFatalError(loc, "invalid type in DotProduct lowering"); fir::emitFatalError(loc, "invalid type in DotProduct lowering");
auto fTy = func.getType(); auto fTy = func.getFunctionType();
auto sourceFile = fir::factory::locationToFilename(builder, loc); auto sourceFile = fir::factory::locationToFilename(builder, loc);
if (fir::isa_complex(eleTy)) { if (fir::isa_complex(eleTy)) {
auto sourceLine = auto sourceLine =
fir::factory::locationToLineNo(builder, loc, fTy.getInput(4)); fir::factory::locationToLineNo(builder, loc, fTy.getInput(4));
auto args = auto args =
fir::runtime::createArguments(builder, loc, fTy, resultBox, vectorABox, fir::runtime::createArguments(builder, loc, fTy, resultBox, vectorABox,
vectorBBox, sourceFile, sourceLine); vectorBBox, sourceFile, sourceLine);
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Lines else if (eleTy == fir::ComplexType::get(builder.getContext(), 8))
func = fir::runtime::getRuntimeFunc<mkRTKey(CppSumComplex8)>(loc, builder); func = fir::runtime::getRuntimeFunc<mkRTKey(CppSumComplex8)>(loc, builder);
else if (eleTy == fir::ComplexType::get(builder.getContext(), 10)) else if (eleTy == fir::ComplexType::get(builder.getContext(), 10))
func = fir::runtime::getRuntimeFunc<ForcedSumComplex10>(loc, builder); func = fir::runtime::getRuntimeFunc<ForcedSumComplex10>(loc, builder);
else if (eleTy == fir::ComplexType::get(builder.getContext(), 16)) else if (eleTy == fir::ComplexType::get(builder.getContext(), 16))
func = fir::runtime::getRuntimeFunc<ForcedSumComplex16>(loc, builder); func = fir::runtime::getRuntimeFunc<ForcedSumComplex16>(loc, builder);
else else
fir::emitFatalError(loc, "invalid type in Sum lowering"); fir::emitFatalError(loc, "invalid type in Sum lowering");
auto fTy = func.getType(); auto fTy = func.getFunctionType();
auto sourceFile = fir::factory::locationToFilename(builder, loc); auto sourceFile = fir::factory::locationToFilename(builder, loc);
if (fir::isa_complex(eleTy)) { if (fir::isa_complex(eleTy)) {
auto sourceLine = auto sourceLine =
fir::factory::locationToLineNo(builder, loc, fTy.getInput(3)); fir::factory::locationToLineNo(builder, loc, fTy.getInput(3));
auto args = auto args =
fir::runtime::createArguments(builder, loc, fTy, resultBox, arrayBox, fir::runtime::createArguments(builder, loc, fTy, resultBox, arrayBox,
sourceFile, sourceLine, dim, maskBox); sourceFile, sourceLine, dim, maskBox);
builder.create<fir::CallOp>(loc, func, args); builder.create<fir::CallOp>(loc, func, args);
Show All 10 Lines

flang/lib/Optimizer/Builder/Runtime/Stop.cpp

Show All 11 Lines
#include "flang/Optimizer/Builder/Runtime/RTBuilder.h" #include "flang/Optimizer/Builder/Runtime/RTBuilder.h"
#include "flang/Runtime/stop.h" #include "flang/Runtime/stop.h"
using namespace Fortran::runtime; using namespace Fortran::runtime;
void fir::runtime::genExit(fir::FirOpBuilder &builder, mlir::Location loc, void fir::runtime::genExit(fir::FirOpBuilder &builder, mlir::Location loc,
mlir::Value status) { mlir::Value status) {
auto exitFunc = fir::runtime::getRuntimeFunc<mkRTKey(Exit)>(loc, builder); auto exitFunc = fir::runtime::getRuntimeFunc<mkRTKey(Exit)>(loc, builder);
llvm::SmallVector<mlir::Value> args = llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments(
fir::runtime::createArguments(builder, loc, exitFunc.getType(), status); builder, loc, exitFunc.getFunctionType(), status);
builder.create<fir::CallOp>(loc, exitFunc, args); builder.create<fir::CallOp>(loc, exitFunc, args);
} }
void fir::runtime::genReportFatalUserError(fir::FirOpBuilder &builder, void fir::runtime::genReportFatalUserError(fir::FirOpBuilder &builder,
mlir::Location loc, mlir::Location loc,
llvm::StringRef message) { llvm::StringRef message) {
mlir::FuncOp crashFunc = mlir::FuncOp crashFunc =
fir::runtime::getRuntimeFunc<mkRTKey(ReportFatalUserError)>(loc, builder); fir::runtime::getRuntimeFunc<mkRTKey(ReportFatalUserError)>(loc, builder);
mlir::FunctionType funcTy = crashFunc.getType(); mlir::FunctionType funcTy = crashFunc.getFunctionType();
mlir::Value msgVal = fir::getBase( mlir::Value msgVal = fir::getBase(
fir::factory::createStringLiteral(builder, loc, message.str() + '\0')); fir::factory::createStringLiteral(builder, loc, message.str() + '\0'));
mlir::Value sourceLine = mlir::Value sourceLine =
fir::factory::locationToLineNo(builder, loc, funcTy.getInput(2)); fir::factory::locationToLineNo(builder, loc, funcTy.getInput(2));
mlir::Value sourceFile = fir::factory::locationToFilename(builder, loc); mlir::Value sourceFile = fir::factory::locationToFilename(builder, loc);
llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments( llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments(
builder, loc, funcTy, msgVal, sourceFile, sourceLine); builder, loc, funcTy, msgVal, sourceFile, sourceLine);
builder.create<fir::CallOp>(loc, crashFunc, args); builder.create<fir::CallOp>(loc, crashFunc, args);
} }

flang/lib/Optimizer/Builder/Runtime/Transformational.cpp

Show All 18 Lines
using namespace Fortran::runtime; using namespace Fortran::runtime;
/// Generate call to Cshift intrinsic /// Generate call to Cshift intrinsic
void fir::runtime::genCshift(fir::FirOpBuilder &builder, mlir::Location loc, void fir::runtime::genCshift(fir::FirOpBuilder &builder, mlir::Location loc,
mlir::Value resultBox, mlir::Value arrayBox, mlir::Value resultBox, mlir::Value arrayBox,
mlir::Value shiftBox, mlir::Value dimBox) { mlir::Value shiftBox, mlir::Value dimBox) {
auto cshiftFunc = fir::runtime::getRuntimeFunc<mkRTKey(Cshift)>(loc, builder); auto cshiftFunc = fir::runtime::getRuntimeFunc<mkRTKey(Cshift)>(loc, builder);
auto fTy = cshiftFunc.getType(); auto fTy = cshiftFunc.getFunctionType();
auto sourceFile = fir::factory::locationToFilename(builder, loc); auto sourceFile = fir::factory::locationToFilename(builder, loc);
auto sourceLine = auto sourceLine =
fir::factory::locationToLineNo(builder, loc, fTy.getInput(5)); fir::factory::locationToLineNo(builder, loc, fTy.getInput(5));
auto args = auto args =
fir::runtime::createArguments(builder, loc, fTy, resultBox, arrayBox, fir::runtime::createArguments(builder, loc, fTy, resultBox, arrayBox,
shiftBox, dimBox, sourceFile, sourceLine); shiftBox, dimBox, sourceFile, sourceLine);
builder.create<fir::CallOp>(loc, cshiftFunc, args); builder.create<fir::CallOp>(loc, cshiftFunc, args);
} }
/// Generate call to the vector version of the Cshift intrinsic /// Generate call to the vector version of the Cshift intrinsic
void fir::runtime::genCshiftVector(fir::FirOpBuilder &builder, void fir::runtime::genCshiftVector(fir::FirOpBuilder &builder,
mlir::Location loc, mlir::Value resultBox, mlir::Location loc, mlir::Value resultBox,
mlir::Value arrayBox, mlir::Value shiftBox) { mlir::Value arrayBox, mlir::Value shiftBox) {
auto cshiftFunc = auto cshiftFunc =
fir::runtime::getRuntimeFunc<mkRTKey(CshiftVector)>(loc, builder); fir::runtime::getRuntimeFunc<mkRTKey(CshiftVector)>(loc, builder);
auto fTy = cshiftFunc.getType(); auto fTy = cshiftFunc.getFunctionType();
auto sourceFile = fir::factory::locationToFilename(builder, loc); auto sourceFile = fir::factory::locationToFilename(builder, loc);
auto sourceLine = auto sourceLine =
fir::factory::locationToLineNo(builder, loc, fTy.getInput(4)); fir::factory::locationToLineNo(builder, loc, fTy.getInput(4));
auto args = fir::runtime::createArguments( auto args = fir::runtime::createArguments(
builder, loc, fTy, resultBox, arrayBox, shiftBox, sourceFile, sourceLine); builder, loc, fTy, resultBox, arrayBox, shiftBox, sourceFile, sourceLine);
builder.create<fir::CallOp>(loc, cshiftFunc, args); builder.create<fir::CallOp>(loc, cshiftFunc, args);
} }
/// Generate call to Eoshift intrinsic /// Generate call to Eoshift intrinsic
void fir::runtime::genEoshift(fir::FirOpBuilder &builder, mlir::Location loc, void fir::runtime::genEoshift(fir::FirOpBuilder &builder, mlir::Location loc,
mlir::Value resultBox, mlir::Value arrayBox, mlir::Value resultBox, mlir::Value arrayBox,
mlir::Value shiftBox, mlir::Value boundBox, mlir::Value shiftBox, mlir::Value boundBox,
mlir::Value dimBox) { mlir::Value dimBox) {
auto eoshiftFunc = auto eoshiftFunc =
fir::runtime::getRuntimeFunc<mkRTKey(Eoshift)>(loc, builder); fir::runtime::getRuntimeFunc<mkRTKey(Eoshift)>(loc, builder);
auto fTy = eoshiftFunc.getType(); auto fTy = eoshiftFunc.getFunctionType();
auto sourceFile = fir::factory::locationToFilename(builder, loc); auto sourceFile = fir::factory::locationToFilename(builder, loc);
auto sourceLine = auto sourceLine =
fir::factory::locationToLineNo(builder, loc, fTy.getInput(6)); fir::factory::locationToLineNo(builder, loc, fTy.getInput(6));
auto args = fir::runtime::createArguments(builder, loc, fTy, resultBox, auto args = fir::runtime::createArguments(builder, loc, fTy, resultBox,
arrayBox, shiftBox, boundBox, arrayBox, shiftBox, boundBox,
dimBox, sourceFile, sourceLine); dimBox, sourceFile, sourceLine);
builder.create<fir::CallOp>(loc, eoshiftFunc, args); builder.create<fir::CallOp>(loc, eoshiftFunc, args);
} }
/// Generate call to the vector version of the Eoshift intrinsic /// Generate call to the vector version of the Eoshift intrinsic
void fir::runtime::genEoshiftVector(fir::FirOpBuilder &builder, void fir::runtime::genEoshiftVector(fir::FirOpBuilder &builder,
mlir::Location loc, mlir::Value resultBox, mlir::Location loc, mlir::Value resultBox,
mlir::Value arrayBox, mlir::Value shiftBox, mlir::Value arrayBox, mlir::Value shiftBox,
mlir::Value boundBox) { mlir::Value boundBox) {
auto eoshiftFunc = auto eoshiftFunc =
fir::runtime::getRuntimeFunc<mkRTKey(EoshiftVector)>(loc, builder); fir::runtime::getRuntimeFunc<mkRTKey(EoshiftVector)>(loc, builder);
auto fTy = eoshiftFunc.getType(); auto fTy = eoshiftFunc.getFunctionType();
auto sourceFile = fir::factory::locationToFilename(builder, loc); auto sourceFile = fir::factory::locationToFilename(builder, loc);
auto sourceLine = auto sourceLine =
fir::factory::locationToLineNo(builder, loc, fTy.getInput(5)); fir::factory::locationToLineNo(builder, loc, fTy.getInput(5));
auto args = auto args =
fir::runtime::createArguments(builder, loc, fTy, resultBox, arrayBox, fir::runtime::createArguments(builder, loc, fTy, resultBox, arrayBox,
shiftBox, boundBox, sourceFile, sourceLine); shiftBox, boundBox, sourceFile, sourceLine);
builder.create<fir::CallOp>(loc, eoshiftFunc, args); builder.create<fir::CallOp>(loc, eoshiftFunc, args);
} }
/// Generate call to Matmul intrinsic runtime routine. /// Generate call to Matmul intrinsic runtime routine.
void fir::runtime::genMatmul(fir::FirOpBuilder &builder, mlir::Location loc, void fir::runtime::genMatmul(fir::FirOpBuilder &builder, mlir::Location loc,
mlir::Value resultBox, mlir::Value matrixABox, mlir::Value resultBox, mlir::Value matrixABox,
mlir::Value matrixBBox) { mlir::Value matrixBBox) {
auto func = fir::runtime::getRuntimeFunc<mkRTKey(Matmul)>(loc, builder); auto func = fir::runtime::getRuntimeFunc<mkRTKey(Matmul)>(loc, builder);
auto fTy = func.getType(); auto fTy = func.getFunctionType();
auto sourceFile = fir::factory::locationToFilename(builder, loc); auto sourceFile = fir::factory::locationToFilename(builder, loc);
auto sourceLine = auto sourceLine =
fir::factory::locationToLineNo(builder, loc, fTy.getInput(4)); fir::factory::locationToLineNo(builder, loc, fTy.getInput(4));
auto args = auto args =
fir::runtime::createArguments(builder, loc, fTy, resultBox, matrixABox, fir::runtime::createArguments(builder, loc, fTy, resultBox, matrixABox,
matrixBBox, sourceFile, sourceLine); matrixBBox, sourceFile, sourceLine);
builder.create<fir::CallOp>(loc, func, args); builder.create<fir::CallOp>(loc, func, args);
} }
/// Generate call to Pack intrinsic runtime routine. /// Generate call to Pack intrinsic runtime routine.
void fir::runtime::genPack(fir::FirOpBuilder &builder, mlir::Location loc, void fir::runtime::genPack(fir::FirOpBuilder &builder, mlir::Location loc,
mlir::Value resultBox, mlir::Value arrayBox, mlir::Value resultBox, mlir::Value arrayBox,
mlir::Value maskBox, mlir::Value vectorBox) { mlir::Value maskBox, mlir::Value vectorBox) {
auto packFunc = fir::runtime::getRuntimeFunc<mkRTKey(Pack)>(loc, builder); auto packFunc = fir::runtime::getRuntimeFunc<mkRTKey(Pack)>(loc, builder);
auto fTy = packFunc.getType(); auto fTy = packFunc.getFunctionType();
auto sourceFile = fir::factory::locationToFilename(builder, loc); auto sourceFile = fir::factory::locationToFilename(builder, loc);
auto sourceLine = auto sourceLine =
fir::factory::locationToLineNo(builder, loc, fTy.getInput(5)); fir::factory::locationToLineNo(builder, loc, fTy.getInput(5));
auto args = auto args =
fir::runtime::createArguments(builder, loc, fTy, resultBox, arrayBox, fir::runtime::createArguments(builder, loc, fTy, resultBox, arrayBox,
maskBox, vectorBox, sourceFile, sourceLine); maskBox, vectorBox, sourceFile, sourceLine);
builder.create<fir::CallOp>(loc, packFunc, args); builder.create<fir::CallOp>(loc, packFunc, args);
} }
/// Generate call to Reshape intrinsic runtime routine. /// Generate call to Reshape intrinsic runtime routine.
void fir::runtime::genReshape(fir::FirOpBuilder &builder, mlir::Location loc, void fir::runtime::genReshape(fir::FirOpBuilder &builder, mlir::Location loc,
mlir::Value resultBox, mlir::Value sourceBox, mlir::Value resultBox, mlir::Value sourceBox,
mlir::Value shapeBox, mlir::Value padBox, mlir::Value shapeBox, mlir::Value padBox,
mlir::Value orderBox) { mlir::Value orderBox) {
auto func = fir::runtime::getRuntimeFunc<mkRTKey(Reshape)>(loc, builder); auto func = fir::runtime::getRuntimeFunc<mkRTKey(Reshape)>(loc, builder);
auto fTy = func.getType(); auto fTy = func.getFunctionType();
auto sourceFile = fir::factory::locationToFilename(builder, loc); auto sourceFile = fir::factory::locationToFilename(builder, loc);
auto sourceLine = auto sourceLine =
fir::factory::locationToLineNo(builder, loc, fTy.getInput(6)); fir::factory::locationToLineNo(builder, loc, fTy.getInput(6));
auto args = fir::runtime::createArguments(builder, loc, fTy, resultBox, auto args = fir::runtime::createArguments(builder, loc, fTy, resultBox,
sourceBox, shapeBox, padBox, sourceBox, shapeBox, padBox,
orderBox, sourceFile, sourceLine); orderBox, sourceFile, sourceLine);
builder.create<fir::CallOp>(loc, func, args); builder.create<fir::CallOp>(loc, func, args);
} }
/// Generate call to Spread intrinsic runtime routine. /// Generate call to Spread intrinsic runtime routine.
void fir::runtime::genSpread(fir::FirOpBuilder &builder, mlir::Location loc, void fir::runtime::genSpread(fir::FirOpBuilder &builder, mlir::Location loc,
mlir::Value resultBox, mlir::Value sourceBox, mlir::Value resultBox, mlir::Value sourceBox,
mlir::Value dim, mlir::Value ncopies) { mlir::Value dim, mlir::Value ncopies) {
auto func = fir::runtime::getRuntimeFunc<mkRTKey(Spread)>(loc, builder); auto func = fir::runtime::getRuntimeFunc<mkRTKey(Spread)>(loc, builder);
auto fTy = func.getType(); auto fTy = func.getFunctionType();
auto sourceFile = fir::factory::locationToFilename(builder, loc); auto sourceFile = fir::factory::locationToFilename(builder, loc);
auto sourceLine = auto sourceLine =
fir::factory::locationToLineNo(builder, loc, fTy.getInput(5)); fir::factory::locationToLineNo(builder, loc, fTy.getInput(5));
auto args = auto args =
fir::runtime::createArguments(builder, loc, fTy, resultBox, sourceBox, fir::runtime::createArguments(builder, loc, fTy, resultBox, sourceBox,
dim, ncopies, sourceFile, sourceLine); dim, ncopies, sourceFile, sourceLine);
builder.create<fir::CallOp>(loc, func, args); builder.create<fir::CallOp>(loc, func, args);
} }
/// Generate call to Transpose intrinsic runtime routine. /// Generate call to Transpose intrinsic runtime routine.
void fir::runtime::genTranspose(fir::FirOpBuilder &builder, mlir::Location loc, void fir::runtime::genTranspose(fir::FirOpBuilder &builder, mlir::Location loc,
mlir::Value resultBox, mlir::Value sourceBox) { mlir::Value resultBox, mlir::Value sourceBox) {
auto func = fir::runtime::getRuntimeFunc<mkRTKey(Transpose)>(loc, builder); auto func = fir::runtime::getRuntimeFunc<mkRTKey(Transpose)>(loc, builder);
auto fTy = func.getType(); auto fTy = func.getFunctionType();
auto sourceFile = fir::factory::locationToFilename(builder, loc); auto sourceFile = fir::factory::locationToFilename(builder, loc);
auto sourceLine = auto sourceLine =
fir::factory::locationToLineNo(builder, loc, fTy.getInput(3)); fir::factory::locationToLineNo(builder, loc, fTy.getInput(3));
auto args = fir::runtime::createArguments(builder, loc, fTy, resultBox, auto args = fir::runtime::createArguments(builder, loc, fTy, resultBox,
sourceBox, sourceFile, sourceLine); sourceBox, sourceFile, sourceLine);
builder.create<fir::CallOp>(loc, func, args); builder.create<fir::CallOp>(loc, func, args);
} }
/// Generate call to Unpack intrinsic runtime routine. /// Generate call to Unpack intrinsic runtime routine.
void fir::runtime::genUnpack(fir::FirOpBuilder &builder, mlir::Location loc, void fir::runtime::genUnpack(fir::FirOpBuilder &builder, mlir::Location loc,
mlir::Value resultBox, mlir::Value vectorBox, mlir::Value resultBox, mlir::Value vectorBox,
mlir::Value maskBox, mlir::Value fieldBox) { mlir::Value maskBox, mlir::Value fieldBox) {
auto unpackFunc = fir::runtime::getRuntimeFunc<mkRTKey(Unpack)>(loc, builder); auto unpackFunc = fir::runtime::getRuntimeFunc<mkRTKey(Unpack)>(loc, builder);
auto fTy = unpackFunc.getType(); auto fTy = unpackFunc.getFunctionType();
auto sourceFile = fir::factory::locationToFilename(builder, loc); auto sourceFile = fir::factory::locationToFilename(builder, loc);
auto sourceLine = auto sourceLine =
fir::factory::locationToLineNo(builder, loc, fTy.getInput(5)); fir::factory::locationToLineNo(builder, loc, fTy.getInput(5));
auto args = auto args =
fir::runtime::createArguments(builder, loc, fTy, resultBox, vectorBox, fir::runtime::createArguments(builder, loc, fTy, resultBox, vectorBox,
maskBox, fieldBox, sourceFile, sourceLine); maskBox, fieldBox, sourceFile, sourceLine);
builder.create<fir::CallOp>(loc, unpackFunc, args); builder.create<fir::CallOp>(loc, unpackFunc, args);
} }

flang/lib/Optimizer/CodeGen/TargetRewrite.cpp

Show First 20 Lines • Show All 448 Lines • ▼ Show 20 Lines for (auto ty : func.getInputs())
return false; return false;
} }
return true; return true;
} }
/// Rewrite the signatures and body of the `FuncOp`s in the module for /// Rewrite the signatures and body of the `FuncOp`s in the module for
/// the immediately subsequent target code gen. /// the immediately subsequent target code gen.
void convertSignature(mlir::FuncOp func) { void convertSignature(mlir::FuncOp func) {
auto funcTy = func.getType().cast<mlir::FunctionType>(); auto funcTy = func.getFunctionType().cast<mlir::FunctionType>();
if (hasPortableSignature(funcTy)) if (hasPortableSignature(funcTy))
return; return;
llvm::SmallVector<mlir::Type> newResTys; llvm::SmallVector<mlir::Type> newResTys;
llvm::SmallVector<mlir::Type> newInTys; llvm::SmallVector<mlir::Type> newInTys;
llvm::SmallVector<FixupTy> fixups; llvm::SmallVector<FixupTy> fixups;
// Convert return value(s) // Convert return value(s)
for (auto ty : funcTy.getResults()) for (auto ty : funcTy.getResults())
▲ Show 20 Lines • Show All 72 Lines • ▼ Show 20 Lines for (auto e : llvm::enumerate(funcTy.getInputs())) {
.Default([&](mlir::Type ty) { newInTys.push_back(ty); }); .Default([&](mlir::Type ty) { newInTys.push_back(ty); });
} }
if (!func.empty()) { if (!func.empty()) {
// If the function has a body, then apply the fixups to the arguments and // If the function has a body, then apply the fixups to the arguments and
// return ops as required. These fixups are done in place. // return ops as required. These fixups are done in place.
auto loc = func.getLoc(); auto loc = func.getLoc();
const auto fixupSize = fixups.size(); const auto fixupSize = fixups.size();
const auto oldArgTys = func.getType().getInputs(); const auto oldArgTys = func.getFunctionType().getInputs();
int offset = 0; int offset = 0;
for (std::remove_const_t<decltype(fixupSize)> i = 0; i < fixupSize; ++i) { for (std::remove_const_t<decltype(fixupSize)> i = 0; i < fixupSize; ++i) {
const auto &fixup = fixups[i]; const auto &fixup = fixups[i];
switch (fixup.code) { switch (fixup.code) {
case FixupTy::Codes::ArgumentAsLoad: { case FixupTy::Codes::ArgumentAsLoad: {
// Argument was pass-by-value, but is now pass-by-reference and // Argument was pass-by-value, but is now pass-by-reference and
// possibly with a different element type. // possibly with a different element type.
auto newArg = func.front().insertArgument(fixup.index, auto newArg = func.front().insertArgument(fixup.index,
▲ Show 20 Lines • Show All 250 Lines • Show Last 20 Lines

flang/lib/Optimizer/Dialect/FIROps.cpp

Show First 20 Lines • Show All 663 Lines • ▼ Show 20 Linesmlir::ParseResult fir::CallOp::parse(mlir::OpAsmParser &parser,
result.attributes = attrs; result.attributes = attrs;
return mlir::success(); return mlir::success();
} }
void fir::CallOp::build(mlir::OpBuilder &builder, mlir::OperationState &result, void fir::CallOp::build(mlir::OpBuilder &builder, mlir::OperationState &result,
mlir::FuncOp callee, mlir::ValueRange operands) { mlir::FuncOp callee, mlir::ValueRange operands) {
result.addOperands(operands); result.addOperands(operands);
result.addAttribute(getCalleeAttrNameStr(), SymbolRefAttr::get(callee)); result.addAttribute(getCalleeAttrNameStr(), SymbolRefAttr::get(callee));
result.addTypes(callee.getType().getResults()); result.addTypes(callee.getFunctionType().getResults());
} }
void fir::CallOp::build(mlir::OpBuilder &builder, mlir::OperationState &result, void fir::CallOp::build(mlir::OpBuilder &builder, mlir::OperationState &result,
mlir::SymbolRefAttr callee, mlir::SymbolRefAttr callee,
llvm::ArrayRef<mlir::Type> results, llvm::ArrayRef<mlir::Type> results,
mlir::ValueRange operands) { mlir::ValueRange operands) {
result.addOperands(operands); result.addOperands(operands);
if (callee) if (callee)
▲ Show 20 Lines • Show All 2,824 Lines • Show Last 20 Lines

flang/lib/Optimizer/Transforms/AbstractResult.cpp

Show First 20 Lines • Show All 216 Lines • ▼ Show 20 Lines void runOnOperation() override {
auto func = getOperation(); auto func = getOperation();
auto loc = func.getLoc(); auto loc = func.getLoc();
mlir::RewritePatternSet patterns(context); mlir::RewritePatternSet patterns(context);
mlir::ConversionTarget target = *context; mlir::ConversionTarget target = *context;
AbstractResultOptions options{passResultAsBox.getValue(), AbstractResultOptions options{passResultAsBox.getValue(),
/*newArg=*/{}}; /*newArg=*/{}};
// Convert function type itself if it has an abstract result // Convert function type itself if it has an abstract result
auto funcTy = func.getType().cast<mlir::FunctionType>(); auto funcTy = func.getFunctionType().cast<mlir::FunctionType>();
if (mustConvertCallOrFunc(funcTy)) { if (mustConvertCallOrFunc(funcTy)) {
func.setType(getNewFunctionType(funcTy, options)); func.setType(getNewFunctionType(funcTy, options));
unsigned zero = 0; unsigned zero = 0;
if (!func.empty()) { if (!func.empty()) {
// Insert new argument // Insert new argument
mlir::OpBuilder rewriter(context); mlir::OpBuilder rewriter(context);
auto resultType = funcTy.getResult(0); auto resultType = funcTy.getResult(0);
auto argTy = getResultArgumentType(resultType, options); auto argTy = getResultArgumentType(resultType, options);
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

mlir/docs/Bindings/Python.md

Show First 20 Lines • Show All 655 Lines • ▼ Show 20 Lines
from mlir.dialects import builtin from mlir.dialects import builtin
with Context(): with Context():
module = Module.create() module = Module.create()
with InsertionPoint(module.body), Location.unknown(): with InsertionPoint(module.body), Location.unknown():
# Operations can be created in a generic way. # Operations can be created in a generic way.
func = Operation.create( func = Operation.create(
"func.func", results=[], operands=[], "func.func", results=[], operands=[],
attributes={"type":TypeAttr.get(FunctionType.get([], []))}, attributes={"function_type":TypeAttr.get(FunctionType.get([], []))},
successors=None, regions=1) successors=None, regions=1)
# The result will be downcasted to the concrete `OpView` subclass if # The result will be downcasted to the concrete `OpView` subclass if
# available. # available.
assert isinstance(func, func.FuncOp) assert isinstance(func, func.FuncOp)
``` ```
Regions are created for an operation when constructing it on the C++ side. They Regions are created for an operation when constructing it on the C++ side. They
are not constructible in Python and are not expected to exist outside of are not constructible in Python and are not expected to exist outside of
▲ Show 20 Lines • Show All 501 Lines • Show Last 20 Lines

mlir/examples/toy/Ch2/include/toy/Ops.td

Show First 20 Lines • Show All 129 Lines • ▼ Show 20 Lines toy.func @main() {
toy.print %1 : tensor<2x2xf64> toy.print %1 : tensor<2x2xf64>
toy.return toy.return
} }
``` ```
}]; }];
let arguments = (ins let arguments = (ins
SymbolNameAttr:$sym_name, SymbolNameAttr:$sym_name,
TypeAttrOf<FunctionType>:$type TypeAttrOf<FunctionType>:$function_type
); );
let regions = (region AnyRegion:$body); let regions = (region AnyRegion:$body);
let builders = [OpBuilder<(ins let builders = [OpBuilder<(ins
"StringRef":$name, "FunctionType":$type, "StringRef":$name, "FunctionType":$type,
CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs) CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)
>]; >];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
//===------------------------------------------------------------------===// //===------------------------------------------------------------------===//
// FunctionOpInterface Methods // FunctionOpInterface Methods
//===------------------------------------------------------------------===// //===------------------------------------------------------------------===//
/// Returns the argument types of this function. /// Returns the argument types of this function.
ArrayRef<Type> getArgumentTypes() { return getType().getInputs(); } ArrayRef<Type> getArgumentTypes() { return getFunctionType().getInputs(); }
/// Returns the result types of this function. /// Returns the result types of this function.
ArrayRef<Type> getResultTypes() { return getType().getResults(); } ArrayRef<Type> getResultTypes() { return getFunctionType().getResults(); }
}]; }];
let hasCustomAssemblyFormat = 1; let hasCustomAssemblyFormat = 1;
let skipDefaultBuilders = 1; let skipDefaultBuilders = 1;
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// GenericCallOp // GenericCallOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 167 Lines • Show Last 20 Lines

mlir/examples/toy/Ch2/mlir/Dialect.cpp

Show First 20 Lines • Show All 246 Lines • ▼ Show 20 Linesmlir::LogicalResult ReturnOp::verify() {
// trait attached to the operation definition. // trait attached to the operation definition.
auto function = cast<FuncOp>((*this)->getParentOp()); auto function = cast<FuncOp>((*this)->getParentOp());
/// ReturnOps can only have a single optional operand. /// ReturnOps can only have a single optional operand.
if (getNumOperands() > 1) if (getNumOperands() > 1)
return emitOpError() << "expects at most 1 return operand"; return emitOpError() << "expects at most 1 return operand";
// The operand number and types must match the function signature. // The operand number and types must match the function signature.
const auto &results = function.getType().getResults(); const auto &results = function.getFunctionType().getResults();
if (getNumOperands() != results.size()) if (getNumOperands() != results.size())
return emitOpError() << "does not return the same number of values (" return emitOpError() << "does not return the same number of values ("
<< getNumOperands() << ") as the enclosing function (" << getNumOperands() << ") as the enclosing function ("
<< results.size() << ")"; << results.size() << ")";
// If the operation does not have an input, we are done. // If the operation does not have an input, we are done.
if (!hasOperand()) if (!hasOperand())
return mlir::success(); return mlir::success();
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

mlir/examples/toy/Ch2/mlir/MLIRGen.cpp

Show First 20 Lines • Show All 155 Lines • ▼ Show 20 Lines mlir::toy::FuncOp mlirGen(FunctionAST &funcAST) {
ReturnOp returnOp; ReturnOp returnOp;
if (!entryBlock.empty()) if (!entryBlock.empty())
returnOp = dyn_cast<ReturnOp>(entryBlock.back()); returnOp = dyn_cast<ReturnOp>(entryBlock.back());
if (!returnOp) { if (!returnOp) {
builder.create<ReturnOp>(loc(funcAST.getProto()->loc())); builder.create<ReturnOp>(loc(funcAST.getProto()->loc()));
} else if (returnOp.hasOperand()) { } else if (returnOp.hasOperand()) {
// Otherwise, if this return operation has an operand then add a result to // Otherwise, if this return operation has an operand then add a result to
// the function. // the function.
function.setType(builder.getFunctionType(function.getType().getInputs(), function.setType(builder.getFunctionType(
getType(VarType{}))); function.getFunctionType().getInputs(), getType(VarType{})));
} }
return function; return function;
} }
/// Emit a binary operation /// Emit a binary operation
mlir::Value mlirGen(BinaryExprAST &binop) { mlir::Value mlirGen(BinaryExprAST &binop) {
// First emit the operations for each side of the operation before emitting // First emit the operations for each side of the operation before emitting
▲ Show 20 Lines • Show All 274 Lines • Show Last 20 Lines

mlir/examples/toy/Ch3/include/toy/Ops.td

Show First 20 Lines • Show All 128 Lines • ▼ Show 20 Lines toy.func @main() {
toy.print %1 : tensor<2x2xf64> toy.print %1 : tensor<2x2xf64>
toy.return toy.return
} }
``` ```
}]; }];
let arguments = (ins let arguments = (ins
SymbolNameAttr:$sym_name, SymbolNameAttr:$sym_name,
TypeAttrOf<FunctionType>:$type TypeAttrOf<FunctionType>:$function_type
); );
let regions = (region AnyRegion:$body); let regions = (region AnyRegion:$body);
let builders = [OpBuilder<(ins let builders = [OpBuilder<(ins
"StringRef":$name, "FunctionType":$type, "StringRef":$name, "FunctionType":$type,
CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs) CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)
>]; >];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
//===------------------------------------------------------------------===// //===------------------------------------------------------------------===//
// FunctionOpInterface Methods // FunctionOpInterface Methods
//===------------------------------------------------------------------===// //===------------------------------------------------------------------===//
/// Returns the argument types of this function. /// Returns the argument types of this function.
ArrayRef<Type> getArgumentTypes() { return getType().getInputs(); } ArrayRef<Type> getArgumentTypes() { return getFunctionType().getInputs(); }
/// Returns the result types of this function. /// Returns the result types of this function.
ArrayRef<Type> getResultTypes() { return getType().getResults(); } ArrayRef<Type> getResultTypes() { return getFunctionType().getResults(); }
}]; }];
let hasCustomAssemblyFormat = 1; let hasCustomAssemblyFormat = 1;
let skipDefaultBuilders = 1; let skipDefaultBuilders = 1;
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// GenericCallOp // GenericCallOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 173 Lines • Show Last 20 Lines

mlir/examples/toy/Ch3/mlir/Dialect.cpp

Show First 20 Lines • Show All 246 Lines • ▼ Show 20 Linesmlir::LogicalResult ReturnOp::verify() {
// trait attached to the operation definition. // trait attached to the operation definition.
auto function = cast<FuncOp>((*this)->getParentOp()); auto function = cast<FuncOp>((*this)->getParentOp());
/// ReturnOps can only have a single optional operand. /// ReturnOps can only have a single optional operand.
if (getNumOperands() > 1) if (getNumOperands() > 1)
return emitOpError() << "expects at most 1 return operand"; return emitOpError() << "expects at most 1 return operand";
// The operand number and types must match the function signature. // The operand number and types must match the function signature.
const auto &results = function.getType().getResults(); const auto &results = function.getFunctionType().getResults();
if (getNumOperands() != results.size()) if (getNumOperands() != results.size())
return emitOpError() << "does not return the same number of values (" return emitOpError() << "does not return the same number of values ("
<< getNumOperands() << ") as the enclosing function (" << getNumOperands() << ") as the enclosing function ("
<< results.size() << ")"; << results.size() << ")";
// If the operation does not have an input, we are done. // If the operation does not have an input, we are done.
if (!hasOperand()) if (!hasOperand())
return mlir::success(); return mlir::success();
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

mlir/examples/toy/Ch3/mlir/MLIRGen.cpp

Show First 20 Lines • Show All 155 Lines • ▼ Show 20 Lines mlir::toy::FuncOp mlirGen(FunctionAST &funcAST) {
ReturnOp returnOp; ReturnOp returnOp;
if (!entryBlock.empty()) if (!entryBlock.empty())
returnOp = dyn_cast<ReturnOp>(entryBlock.back()); returnOp = dyn_cast<ReturnOp>(entryBlock.back());
if (!returnOp) { if (!returnOp) {
builder.create<ReturnOp>(loc(funcAST.getProto()->loc())); builder.create<ReturnOp>(loc(funcAST.getProto()->loc()));
} else if (returnOp.hasOperand()) { } else if (returnOp.hasOperand()) {
// Otherwise, if this return operation has an operand then add a result to // Otherwise, if this return operation has an operand then add a result to
// the function. // the function.
function.setType(builder.getFunctionType(function.getType().getInputs(), function.setType(builder.getFunctionType(
getType(VarType{}))); function.getFunctionType().getInputs(), getType(VarType{})));
} }
return function; return function;
} }
/// Emit a binary operation /// Emit a binary operation
mlir::Value mlirGen(BinaryExprAST &binop) { mlir::Value mlirGen(BinaryExprAST &binop) {
// First emit the operations for each side of the operation before emitting // First emit the operations for each side of the operation before emitting
▲ Show 20 Lines • Show All 274 Lines • Show Last 20 Lines

mlir/examples/toy/Ch4/include/toy/Ops.td

Show First 20 Lines • Show All 158 Lines • ▼ Show 20 Lines toy.func @main() {
toy.print %1 : tensor<2x2xf64> toy.print %1 : tensor<2x2xf64>
toy.return toy.return
} }
``` ```
}]; }];
let arguments = (ins let arguments = (ins
SymbolNameAttr:$sym_name, SymbolNameAttr:$sym_name,
TypeAttrOf<FunctionType>:$type TypeAttrOf<FunctionType>:$function_type
); );
let regions = (region AnyRegion:$body); let regions = (region AnyRegion:$body);
let builders = [OpBuilder<(ins let builders = [OpBuilder<(ins
"StringRef":$name, "FunctionType":$type, "StringRef":$name, "FunctionType":$type,
CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs) CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)
>]; >];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
//===------------------------------------------------------------------===// //===------------------------------------------------------------------===//
// FunctionOpInterface Methods // FunctionOpInterface Methods
//===------------------------------------------------------------------===// //===------------------------------------------------------------------===//
/// Returns the argument types of this function. /// Returns the argument types of this function.
ArrayRef<Type> getArgumentTypes() { return getType().getInputs(); } ArrayRef<Type> getArgumentTypes() { return getFunctionType().getInputs(); }
/// Returns the result types of this function. /// Returns the result types of this function.
ArrayRef<Type> getResultTypes() { return getType().getResults(); } ArrayRef<Type> getResultTypes() { return getFunctionType().getResults(); }
}]; }];
let hasCustomAssemblyFormat = 1; let hasCustomAssemblyFormat = 1;
let skipDefaultBuilders = 1; let skipDefaultBuilders = 1;
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// GenericCallOp // GenericCallOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 176 Lines • Show Last 20 Lines

mlir/examples/toy/Ch4/mlir/Dialect.cpp

Show First 20 Lines • Show All 297 Lines • ▼ Show 20 Lines
} }
/// Returns the region on the function operation that is callable. /// Returns the region on the function operation that is callable.
mlir::Region *FuncOp::getCallableRegion() { return &getBody(); } mlir::Region *FuncOp::getCallableRegion() { return &getBody(); }
/// Returns the results types that the callable region produces when /// Returns the results types that the callable region produces when
/// executed. /// executed.
llvm::ArrayRef<mlir::Type> FuncOp::getCallableResults() { llvm::ArrayRef<mlir::Type> FuncOp::getCallableResults() {
return getType().getResults(); return getFunctionType().getResults();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// GenericCallOp // GenericCallOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void GenericCallOp::build(mlir::OpBuilder &builder, mlir::OperationState &state, void GenericCallOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
StringRef callee, ArrayRef<mlir::Value> arguments) { StringRef callee, ArrayRef<mlir::Value> arguments) {
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Linesmlir::LogicalResult ReturnOp::verify() {
// trait attached to the operation definition. // trait attached to the operation definition.
auto function = cast<FuncOp>((*this)->getParentOp()); auto function = cast<FuncOp>((*this)->getParentOp());
/// ReturnOps can only have a single optional operand. /// ReturnOps can only have a single optional operand.
if (getNumOperands() > 1) if (getNumOperands() > 1)
return emitOpError() << "expects at most 1 return operand"; return emitOpError() << "expects at most 1 return operand";
// The operand number and types must match the function signature. // The operand number and types must match the function signature.
const auto &results = function.getType().getResults(); const auto &results = function.getFunctionType().getResults();
if (getNumOperands() != results.size()) if (getNumOperands() != results.size())
return emitOpError() << "does not return the same number of values (" return emitOpError() << "does not return the same number of values ("
<< getNumOperands() << ") as the enclosing function (" << getNumOperands() << ") as the enclosing function ("
<< results.size() << ")"; << results.size() << ")";
// If the operation does not have an input, we are done. // If the operation does not have an input, we are done.
if (!hasOperand()) if (!hasOperand())
return mlir::success(); return mlir::success();
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

mlir/examples/toy/Ch4/mlir/MLIRGen.cpp

Show First 20 Lines • Show All 155 Lines • ▼ Show 20 Lines mlir::toy::FuncOp mlirGen(FunctionAST &funcAST) {
ReturnOp returnOp; ReturnOp returnOp;
if (!entryBlock.empty()) if (!entryBlock.empty())
returnOp = dyn_cast<ReturnOp>(entryBlock.back()); returnOp = dyn_cast<ReturnOp>(entryBlock.back());
if (!returnOp) { if (!returnOp) {
builder.create<ReturnOp>(loc(funcAST.getProto()->loc())); builder.create<ReturnOp>(loc(funcAST.getProto()->loc()));
} else if (returnOp.hasOperand()) { } else if (returnOp.hasOperand()) {
// Otherwise, if this return operation has an operand then add a result to // Otherwise, if this return operation has an operand then add a result to
// the function. // the function.
function.setType(builder.getFunctionType(function.getType().getInputs(), function.setType(builder.getFunctionType(
getType(VarType{}))); function.getFunctionType().getInputs(), getType(VarType{})));
} }
// If this function isn't main, then set the visibility to private. // If this function isn't main, then set the visibility to private.
if (funcAST.getProto()->getName() != "main") if (funcAST.getProto()->getName() != "main")
function.setPrivate(); function.setPrivate();
return function; return function;
} }
▲ Show 20 Lines • Show All 278 Lines • Show Last 20 Lines

mlir/examples/toy/Ch5/include/toy/Ops.td

Show First 20 Lines • Show All 158 Lines • ▼ Show 20 Lines toy.func @main() {
toy.print %1 : tensor<2x2xf64> toy.print %1 : tensor<2x2xf64>
toy.return toy.return
} }
``` ```
}]; }];
let arguments = (ins let arguments = (ins
SymbolNameAttr:$sym_name, SymbolNameAttr:$sym_name,
TypeAttrOf<FunctionType>:$type TypeAttrOf<FunctionType>:$function_type
); );
let regions = (region AnyRegion:$body); let regions = (region AnyRegion:$body);
let builders = [OpBuilder<(ins let builders = [OpBuilder<(ins
"StringRef":$name, "FunctionType":$type, "StringRef":$name, "FunctionType":$type,
CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs) CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)
>]; >];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
//===------------------------------------------------------------------===// //===------------------------------------------------------------------===//
// FunctionOpInterface Methods // FunctionOpInterface Methods
//===------------------------------------------------------------------===// //===------------------------------------------------------------------===//
/// Returns the argument types of this function. /// Returns the argument types of this function.
ArrayRef<Type> getArgumentTypes() { return getType().getInputs(); } ArrayRef<Type> getArgumentTypes() { return getFunctionType().getInputs(); }
/// Returns the result types of this function. /// Returns the result types of this function.
ArrayRef<Type> getResultTypes() { return getType().getResults(); } ArrayRef<Type> getResultTypes() { return getFunctionType().getResults(); }
}]; }];
let hasCustomAssemblyFormat = 1; let hasCustomAssemblyFormat = 1;
let skipDefaultBuilders = 1; let skipDefaultBuilders = 1;
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// GenericCallOp // GenericCallOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 177 Lines • Show Last 20 Lines

mlir/examples/toy/Ch5/mlir/Dialect.cpp

Show First 20 Lines • Show All 297 Lines • ▼ Show 20 Lines
} }
/// Returns the region on the function operation that is callable. /// Returns the region on the function operation that is callable.
mlir::Region *FuncOp::getCallableRegion() { return &getBody(); } mlir::Region *FuncOp::getCallableRegion() { return &getBody(); }
/// Returns the results types that the callable region produces when /// Returns the results types that the callable region produces when
/// executed. /// executed.
llvm::ArrayRef<mlir::Type> FuncOp::getCallableResults() { llvm::ArrayRef<mlir::Type> FuncOp::getCallableResults() {
return getType().getResults(); return getFunctionType().getResults();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// GenericCallOp // GenericCallOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void GenericCallOp::build(mlir::OpBuilder &builder, mlir::OperationState &state, void GenericCallOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
StringRef callee, ArrayRef<mlir::Value> arguments) { StringRef callee, ArrayRef<mlir::Value> arguments) {
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Linesmlir::LogicalResult ReturnOp::verify() {
// trait attached to the operation definition. // trait attached to the operation definition.
auto function = cast<FuncOp>((*this)->getParentOp()); auto function = cast<FuncOp>((*this)->getParentOp());
/// ReturnOps can only have a single optional operand. /// ReturnOps can only have a single optional operand.
if (getNumOperands() > 1) if (getNumOperands() > 1)
return emitOpError() << "expects at most 1 return operand"; return emitOpError() << "expects at most 1 return operand";
// The operand number and types must match the function signature. // The operand number and types must match the function signature.
const auto &results = function.getType().getResults(); const auto &results = function.getFunctionType().getResults();
if (getNumOperands() != results.size()) if (getNumOperands() != results.size())
return emitOpError() << "does not return the same number of values (" return emitOpError() << "does not return the same number of values ("
<< getNumOperands() << ") as the enclosing function (" << getNumOperands() << ") as the enclosing function ("
<< results.size() << ")"; << results.size() << ")";
// If the operation does not have an input, we are done. // If the operation does not have an input, we are done.
if (!hasOperand()) if (!hasOperand())
return mlir::success(); return mlir::success();
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

mlir/examples/toy/Ch5/mlir/LowerToAffineLoops.cpp

Show First 20 Lines • Show All 208 Lines • ▼ Show 20 Linesstruct FuncOpLowering : public OpConversionPattern<toy::FuncOp> {
matchAndRewrite(toy::FuncOp op, OpAdaptor adaptor, matchAndRewrite(toy::FuncOp op, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const final { ConversionPatternRewriter &rewriter) const final {
// We only lower the main function as we expect that all other functions // We only lower the main function as we expect that all other functions
// have been inlined. // have been inlined.
if (op.getName() != "main") if (op.getName() != "main")
return failure(); return failure();
// Verify that the given main has no inputs and results. // Verify that the given main has no inputs and results.
if (op.getNumArguments() || op.getType().getNumResults()) { if (op.getNumArguments() || op.getFunctionType().getNumResults()) {
return rewriter.notifyMatchFailure(op, [](Diagnostic &diag) { return rewriter.notifyMatchFailure(op, [](Diagnostic &diag) {
diag << "expected 'main' to have 0 inputs and 0 results"; diag << "expected 'main' to have 0 inputs and 0 results";
}); });
} }
// Create a new non-toy function, with the same region. // Create a new non-toy function, with the same region.
auto func = auto func = rewriter.create<mlir::FuncOp>(op.getLoc(), op.getName(),
rewriter.create<mlir::FuncOp>(op.getLoc(), op.getName(), op.getType()); op.getFunctionType());
rewriter.inlineRegionBefore(op.getRegion(), func.getBody(), func.end()); rewriter.inlineRegionBefore(op.getRegion(), func.getBody(), func.end());
rewriter.eraseOp(op); rewriter.eraseOp(op);
return success(); return success();
} }
}; };
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ToyToAffine RewritePatterns: Print operations // ToyToAffine RewritePatterns: Print operations
▲ Show 20 Lines • Show All 130 Lines • Show Last 20 Lines

mlir/examples/toy/Ch5/mlir/MLIRGen.cpp

Show First 20 Lines • Show All 155 Lines • ▼ Show 20 Lines mlir::toy::FuncOp mlirGen(FunctionAST &funcAST) {
ReturnOp returnOp; ReturnOp returnOp;
if (!entryBlock.empty()) if (!entryBlock.empty())
returnOp = dyn_cast<ReturnOp>(entryBlock.back()); returnOp = dyn_cast<ReturnOp>(entryBlock.back());
if (!returnOp) { if (!returnOp) {
builder.create<ReturnOp>(loc(funcAST.getProto()->loc())); builder.create<ReturnOp>(loc(funcAST.getProto()->loc()));
} else if (returnOp.hasOperand()) { } else if (returnOp.hasOperand()) {
// Otherwise, if this return operation has an operand then add a result to // Otherwise, if this return operation has an operand then add a result to
// the function. // the function.
function.setType(builder.getFunctionType(function.getType().getInputs(), function.setType(builder.getFunctionType(
getType(VarType{}))); function.getFunctionType().getInputs(), getType(VarType{})));
} }
// If this function isn't main, then set the visibility to private. // If this function isn't main, then set the visibility to private.
if (funcAST.getProto()->getName() != "main") if (funcAST.getProto()->getName() != "main")
function.setPrivate(); function.setPrivate();
return function; return function;
} }
▲ Show 20 Lines • Show All 278 Lines • Show Last 20 Lines

mlir/examples/toy/Ch6/include/toy/Ops.td

Show First 20 Lines • Show All 158 Lines • ▼ Show 20 Lines toy.func @main() {
toy.print %1 : tensor<2x2xf64> toy.print %1 : tensor<2x2xf64>
toy.return toy.return
} }
``` ```
}]; }];
let arguments = (ins let arguments = (ins
SymbolNameAttr:$sym_name, SymbolNameAttr:$sym_name,
TypeAttrOf<FunctionType>:$type TypeAttrOf<FunctionType>:$function_type
); );
let regions = (region AnyRegion:$body); let regions = (region AnyRegion:$body);
let builders = [OpBuilder<(ins let builders = [OpBuilder<(ins
"StringRef":$name, "FunctionType":$type, "StringRef":$name, "FunctionType":$type,
CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs) CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)
>]; >];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
//===------------------------------------------------------------------===// //===------------------------------------------------------------------===//
// FunctionOpInterface Methods // FunctionOpInterface Methods
//===------------------------------------------------------------------===// //===------------------------------------------------------------------===//
/// Returns the argument types of this function. /// Returns the argument types of this function.
ArrayRef<Type> getArgumentTypes() { return getType().getInputs(); } ArrayRef<Type> getArgumentTypes() { return getFunctionType().getInputs(); }
/// Returns the result types of this function. /// Returns the result types of this function.
ArrayRef<Type> getResultTypes() { return getType().getResults(); } ArrayRef<Type> getResultTypes() { return getFunctionType().getResults(); }
}]; }];
let hasCustomAssemblyFormat = 1; let hasCustomAssemblyFormat = 1;
let skipDefaultBuilders = 1; let skipDefaultBuilders = 1;
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// GenericCallOp // GenericCallOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 177 Lines • Show Last 20 Lines

mlir/examples/toy/Ch6/mlir/Dialect.cpp

Show First 20 Lines • Show All 297 Lines • ▼ Show 20 Lines
} }
/// Returns the region on the function operation that is callable. /// Returns the region on the function operation that is callable.
mlir::Region *FuncOp::getCallableRegion() { return &getBody(); } mlir::Region *FuncOp::getCallableRegion() { return &getBody(); }
/// Returns the results types that the callable region produces when /// Returns the results types that the callable region produces when
/// executed. /// executed.
llvm::ArrayRef<mlir::Type> FuncOp::getCallableResults() { llvm::ArrayRef<mlir::Type> FuncOp::getCallableResults() {
return getType().getResults(); return getFunctionType().getResults();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// GenericCallOp // GenericCallOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void GenericCallOp::build(mlir::OpBuilder &builder, mlir::OperationState &state, void GenericCallOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
StringRef callee, ArrayRef<mlir::Value> arguments) { StringRef callee, ArrayRef<mlir::Value> arguments) {
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Linesmlir::LogicalResult ReturnOp::verify() {
// trait attached to the operation definition. // trait attached to the operation definition.
auto function = cast<FuncOp>((*this)->getParentOp()); auto function = cast<FuncOp>((*this)->getParentOp());
/// ReturnOps can only have a single optional operand. /// ReturnOps can only have a single optional operand.
if (getNumOperands() > 1) if (getNumOperands() > 1)
return emitOpError() << "expects at most 1 return operand"; return emitOpError() << "expects at most 1 return operand";
// The operand number and types must match the function signature. // The operand number and types must match the function signature.
const auto &results = function.getType().getResults(); const auto &results = function.getFunctionType().getResults();
if (getNumOperands() != results.size()) if (getNumOperands() != results.size())
return emitOpError() << "does not return the same number of values (" return emitOpError() << "does not return the same number of values ("
<< getNumOperands() << ") as the enclosing function (" << getNumOperands() << ") as the enclosing function ("
<< results.size() << ")"; << results.size() << ")";
// If the operation does not have an input, we are done. // If the operation does not have an input, we are done.
if (!hasOperand()) if (!hasOperand())
return mlir::success(); return mlir::success();
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

mlir/examples/toy/Ch6/mlir/LowerToAffineLoops.cpp

Show First 20 Lines • Show All 208 Lines • ▼ Show 20 Linesstruct FuncOpLowering : public OpConversionPattern<toy::FuncOp> {
matchAndRewrite(toy::FuncOp op, OpAdaptor adaptor, matchAndRewrite(toy::FuncOp op, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const final { ConversionPatternRewriter &rewriter) const final {
// We only lower the main function as we expect that all other functions // We only lower the main function as we expect that all other functions
// have been inlined. // have been inlined.
if (op.getName() != "main") if (op.getName() != "main")
return failure(); return failure();
// Verify that the given main has no inputs and results. // Verify that the given main has no inputs and results.
if (op.getNumArguments() || op.getType().getNumResults()) { if (op.getNumArguments() || op.getFunctionType().getNumResults()) {
return rewriter.notifyMatchFailure(op, [](Diagnostic &diag) { return rewriter.notifyMatchFailure(op, [](Diagnostic &diag) {
diag << "expected 'main' to have 0 inputs and 0 results"; diag << "expected 'main' to have 0 inputs and 0 results";
}); });
} }
// Create a new non-toy function, with the same region. // Create a new non-toy function, with the same region.
auto func = auto func = rewriter.create<mlir::FuncOp>(op.getLoc(), op.getName(),
rewriter.create<mlir::FuncOp>(op.getLoc(), op.getName(), op.getType()); op.getFunctionType());
rewriter.inlineRegionBefore(op.getRegion(), func.getBody(), func.end()); rewriter.inlineRegionBefore(op.getRegion(), func.getBody(), func.end());
rewriter.eraseOp(op); rewriter.eraseOp(op);
return success(); return success();
} }
}; };
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ToyToAffine RewritePatterns: Print operations // ToyToAffine RewritePatterns: Print operations
▲ Show 20 Lines • Show All 130 Lines • Show Last 20 Lines

mlir/examples/toy/Ch6/mlir/MLIRGen.cpp

Show First 20 Lines • Show All 155 Lines • ▼ Show 20 Lines mlir::toy::FuncOp mlirGen(FunctionAST &funcAST) {
ReturnOp returnOp; ReturnOp returnOp;
if (!entryBlock.empty()) if (!entryBlock.empty())
returnOp = dyn_cast<ReturnOp>(entryBlock.back()); returnOp = dyn_cast<ReturnOp>(entryBlock.back());
if (!returnOp) { if (!returnOp) {
builder.create<ReturnOp>(loc(funcAST.getProto()->loc())); builder.create<ReturnOp>(loc(funcAST.getProto()->loc()));
} else if (returnOp.hasOperand()) { } else if (returnOp.hasOperand()) {
// Otherwise, if this return operation has an operand then add a result to // Otherwise, if this return operation has an operand then add a result to
// the function. // the function.
function.setType(builder.getFunctionType(function.getType().getInputs(), function.setType(builder.getFunctionType(
getType(VarType{}))); function.getFunctionType().getInputs(), getType(VarType{})));
} }
// If this function isn't main, then set the visibility to private. // If this function isn't main, then set the visibility to private.
if (funcAST.getProto()->getName() != "main") if (funcAST.getProto()->getName() != "main")
function.setPrivate(); function.setPrivate();
return function; return function;
} }
▲ Show 20 Lines • Show All 278 Lines • Show Last 20 Lines

mlir/examples/toy/Ch7/include/toy/Ops.td

Show First 20 Lines • Show All 177 Lines • ▼ Show 20 Lines toy.func @main() {
toy.print %1 : tensor<2x2xf64> toy.print %1 : tensor<2x2xf64>
toy.return toy.return
} }
``` ```
}]; }];
let arguments = (ins let arguments = (ins
SymbolNameAttr:$sym_name, SymbolNameAttr:$sym_name,
TypeAttrOf<FunctionType>:$type TypeAttrOf<FunctionType>:$function_type
); );
let regions = (region AnyRegion:$body); let regions = (region AnyRegion:$body);
let builders = [OpBuilder<(ins let builders = [OpBuilder<(ins
"StringRef":$name, "FunctionType":$type, "StringRef":$name, "FunctionType":$type,
CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs) CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)
>]; >];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
//===------------------------------------------------------------------===// //===------------------------------------------------------------------===//
// FunctionOpInterface Methods // FunctionOpInterface Methods
//===------------------------------------------------------------------===// //===------------------------------------------------------------------===//
/// Returns the argument types of this function. /// Returns the argument types of this function.
ArrayRef<Type> getArgumentTypes() { return getType().getInputs(); } ArrayRef<Type> getArgumentTypes() { return getFunctionType().getInputs(); }
/// Returns the result types of this function. /// Returns the result types of this function.
ArrayRef<Type> getResultTypes() { return getType().getResults(); } ArrayRef<Type> getResultTypes() { return getFunctionType().getResults(); }
}]; }];
let hasCustomAssemblyFormat = 1; let hasCustomAssemblyFormat = 1;
let skipDefaultBuilders = 1; let skipDefaultBuilders = 1;
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// GenericCallOp // GenericCallOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 235 Lines • Show Last 20 Lines

mlir/examples/toy/Ch7/mlir/Dialect.cpp

Show First 20 Lines • Show All 324 Lines • ▼ Show 20 Lines
} }
/// Returns the region on the function operation that is callable. /// Returns the region on the function operation that is callable.
mlir::Region *FuncOp::getCallableRegion() { return &getBody(); } mlir::Region *FuncOp::getCallableRegion() { return &getBody(); }
/// Returns the results types that the callable region produces when /// Returns the results types that the callable region produces when
/// executed. /// executed.
llvm::ArrayRef<mlir::Type> FuncOp::getCallableResults() { llvm::ArrayRef<mlir::Type> FuncOp::getCallableResults() {
return getType().getResults(); return getFunctionType().getResults();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// GenericCallOp // GenericCallOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void GenericCallOp::build(mlir::OpBuilder &builder, mlir::OperationState &state, void GenericCallOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
StringRef callee, ArrayRef<mlir::Value> arguments) { StringRef callee, ArrayRef<mlir::Value> arguments) {
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Linesmlir::LogicalResult ReturnOp::verify() {
// trait attached to the operation definition. // trait attached to the operation definition.
auto function = cast<FuncOp>((*this)->getParentOp()); auto function = cast<FuncOp>((*this)->getParentOp());
/// ReturnOps can only have a single optional operand. /// ReturnOps can only have a single optional operand.
if (getNumOperands() > 1) if (getNumOperands() > 1)
return emitOpError() << "expects at most 1 return operand"; return emitOpError() << "expects at most 1 return operand";
// The operand number and types must match the function signature. // The operand number and types must match the function signature.
const auto &results = function.getType().getResults(); const auto &results = function.getFunctionType().getResults();
if (getNumOperands() != results.size()) if (getNumOperands() != results.size())
return emitOpError() << "does not return the same number of values (" return emitOpError() << "does not return the same number of values ("
<< getNumOperands() << ") as the enclosing function (" << getNumOperands() << ") as the enclosing function ("
<< results.size() << ")"; << results.size() << ")";
// If the operation does not have an input, we are done. // If the operation does not have an input, we are done.
if (!hasOperand()) if (!hasOperand())
return mlir::success(); return mlir::success();
▲ Show 20 Lines • Show All 238 Lines • Show Last 20 Lines

mlir/examples/toy/Ch7/mlir/LowerToAffineLoops.cpp

Show First 20 Lines • Show All 208 Lines • ▼ Show 20 Linesstruct FuncOpLowering : public OpConversionPattern<toy::FuncOp> {
matchAndRewrite(toy::FuncOp op, OpAdaptor adaptor, matchAndRewrite(toy::FuncOp op, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const final { ConversionPatternRewriter &rewriter) const final {
// We only lower the main function as we expect that all other functions // We only lower the main function as we expect that all other functions
// have been inlined. // have been inlined.
if (op.getName() != "main") if (op.getName() != "main")
return failure(); return failure();
// Verify that the given main has no inputs and results. // Verify that the given main has no inputs and results.
if (op.getNumArguments() || op.getType().getNumResults()) { if (op.getNumArguments() || op.getFunctionType().getNumResults()) {
return rewriter.notifyMatchFailure(op, [](Diagnostic &diag) { return rewriter.notifyMatchFailure(op, [](Diagnostic &diag) {
diag << "expected 'main' to have 0 inputs and 0 results"; diag << "expected 'main' to have 0 inputs and 0 results";
}); });
} }
// Create a new non-toy function, with the same region. // Create a new non-toy function, with the same region.
auto func = auto func = rewriter.create<mlir::FuncOp>(op.getLoc(), op.getName(),
rewriter.create<mlir::FuncOp>(op.getLoc(), op.getName(), op.getType()); op.getFunctionType());
rewriter.inlineRegionBefore(op.getRegion(), func.getBody(), func.end()); rewriter.inlineRegionBefore(op.getRegion(), func.getBody(), func.end());
rewriter.eraseOp(op); rewriter.eraseOp(op);
return success(); return success();
} }
}; };
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ToyToAffine RewritePatterns: Print operations // ToyToAffine RewritePatterns: Print operations
▲ Show 20 Lines • Show All 130 Lines • Show Last 20 Lines

mlir/examples/toy/Ch7/mlir/MLIRGen.cpp

Show First 20 Lines • Show All 210 Lines • ▼ Show 20 Lines mlir::toy::FuncOp mlirGen(FunctionAST &funcAST) {
ReturnOp returnOp; ReturnOp returnOp;
if (!entryBlock.empty()) if (!entryBlock.empty())
returnOp = dyn_cast<ReturnOp>(entryBlock.back()); returnOp = dyn_cast<ReturnOp>(entryBlock.back());
if (!returnOp) { if (!returnOp) {
builder.create<ReturnOp>(loc(funcAST.getProto()->loc())); builder.create<ReturnOp>(loc(funcAST.getProto()->loc()));
} else if (returnOp.hasOperand()) { } else if (returnOp.hasOperand()) {
// Otherwise, if this return operation has an operand then add a result to // Otherwise, if this return operation has an operand then add a result to
// the function. // the function.
function.setType(builder.getFunctionType(function.getType().getInputs(), function.setType(
builder.getFunctionType(function.getFunctionType().getInputs(),
*returnOp.operand_type_begin())); *returnOp.operand_type_begin()));
} }
// If this function isn't main, then set the visibility to private. // If this function isn't main, then set the visibility to private.
if (funcAST.getProto()->getName() != "main") if (funcAST.getProto()->getName() != "main")
function.setPrivate(); function.setPrivate();
return function; return function;
} }
▲ Show 20 Lines • Show All 285 Lines • ▼ Show 20 Lines mlir::Value mlirGen(CallExprAST &call) {
// name as an attribute. // name as an attribute.
auto calledFuncIt = functionMap.find(callee); auto calledFuncIt = functionMap.find(callee);
if (calledFuncIt == functionMap.end()) { if (calledFuncIt == functionMap.end()) {
emitError(location) << "no defined function found for '" << callee << "'"; emitError(location) << "no defined function found for '" << callee << "'";
return nullptr; return nullptr;
} }
mlir::toy::FuncOp calledFunc = calledFuncIt->second; mlir::toy::FuncOp calledFunc = calledFuncIt->second;
return builder.create<GenericCallOp>( return builder.create<GenericCallOp>(
location, calledFunc.getType().getResult(0), location, calledFunc.getFunctionType().getResult(0),
mlir::SymbolRefAttr::get(builder.getContext(), callee), operands); mlir::SymbolRefAttr::get(builder.getContext(), callee), operands);
} }
/// Emit a print expression. It emits specific operations for two builtins: /// Emit a print expression. It emits specific operations for two builtins:
/// transpose(x) and print(x). /// transpose(x) and print(x).
mlir::LogicalResult mlirGen(PrintExprAST &call) { mlir::LogicalResult mlirGen(PrintExprAST &call) {
auto arg = mlirGen(*call.getArg()); auto arg = mlirGen(*call.getArg());
if (!arg) if (!arg)
▲ Show 20 Lines • Show All 145 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/Func/IR/FuncOps.td

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Linesdef CallOp : Func_Op<"call",
let arguments = (ins FlatSymbolRefAttr:$callee, Variadic<AnyType>:$operands); let arguments = (ins FlatSymbolRefAttr:$callee, Variadic<AnyType>:$operands);
let results = (outs Variadic<AnyType>); let results = (outs Variadic<AnyType>);
let builders = [ let builders = [
OpBuilder<(ins "FuncOp":$callee, CArg<"ValueRange", "{}">:$operands), [{ OpBuilder<(ins "FuncOp":$callee, CArg<"ValueRange", "{}">:$operands), [{
$_state.addOperands(operands); $_state.addOperands(operands);
$_state.addAttribute("callee", SymbolRefAttr::get(callee)); $_state.addAttribute("callee", SymbolRefAttr::get(callee));
$_state.addTypes(callee.getType().getResults()); $_state.addTypes(callee.getFunctionType().getResults());
}]>, }]>,
OpBuilder<(ins "SymbolRefAttr":$callee, "TypeRange":$results, OpBuilder<(ins "SymbolRefAttr":$callee, "TypeRange":$results,
CArg<"ValueRange", "{}">:$operands), [{ CArg<"ValueRange", "{}">:$operands), [{
$_state.addOperands(operands); $_state.addOperands(operands);
$_state.addAttribute("callee", callee); $_state.addAttribute("callee", callee);
$_state.addTypes(results); $_state.addTypes(results);
}]>, }]>,
OpBuilder<(ins "StringAttr":$callee, "TypeRange":$results, OpBuilder<(ins "StringAttr":$callee, "TypeRange":$results,
▲ Show 20 Lines • Show All 176 Lines • ▼ Show 20 Lines let description = [{
func.func @example_fn_result() -> (f64 {dialectName.attrName = 0 : i64}) func.func @example_fn_result() -> (f64 {dialectName.attrName = 0 : i64})
// A function with an attribute // A function with an attribute
func.func @example_fn_attr() attributes {dialectName.attrName = false} func.func @example_fn_attr() attributes {dialectName.attrName = false}
``` ```
}]; }];
let arguments = (ins SymbolNameAttr:$sym_name, let arguments = (ins SymbolNameAttr:$sym_name,
TypeAttrOf<FunctionType>:$type, TypeAttrOf<FunctionType>:$function_type,
OptionalAttr<StrAttr>:$sym_visibility); OptionalAttr<StrAttr>:$sym_visibility);
let regions = (region AnyRegion:$body); let regions = (region AnyRegion:$body);
let builders = [OpBuilder<(ins let builders = [OpBuilder<(ins
"StringRef":$name, "FunctionType":$type, "StringRef":$name, "FunctionType":$type,
CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs, CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs,
CArg<"ArrayRef<DictionaryAttr>", "{}">:$argAttrs) CArg<"ArrayRef<DictionaryAttr>", "{}">:$argAttrs)
>]; >];
Show All 28 Lines let extraClassDeclaration = [{
/// Returns the region on the current operation that is callable. This may /// Returns the region on the current operation that is callable. This may
/// return null in the case of an external callable object, e.g. an external /// return null in the case of an external callable object, e.g. an external
/// function. /// function.
::mlir::Region *getCallableRegion() { return isExternal() ? nullptr : &getBody(); } ::mlir::Region *getCallableRegion() { return isExternal() ? nullptr : &getBody(); }
/// Returns the results types that the callable region produces when /// Returns the results types that the callable region produces when
/// executed. /// executed.
ArrayRef<Type> getCallableResults() { return getType().getResults(); } ArrayRef<Type> getCallableResults() { return getFunctionType().getResults(); }
//===------------------------------------------------------------------===// //===------------------------------------------------------------------===//
// FunctionOpInterface Methods // FunctionOpInterface Methods
//===------------------------------------------------------------------===// //===------------------------------------------------------------------===//
/// Returns the argument types of this function. /// Returns the argument types of this function.
ArrayRef<Type> getArgumentTypes() { return getType().getInputs(); } ArrayRef<Type> getArgumentTypes() { return getFunctionType().getInputs(); }
/// Returns the result types of this function. /// Returns the result types of this function.
ArrayRef<Type> getResultTypes() { return getType().getResults(); } ArrayRef<Type> getResultTypes() { return getFunctionType().getResults(); }
//===------------------------------------------------------------------===// //===------------------------------------------------------------------===//
// SymbolOpInterface Methods // SymbolOpInterface Methods
//===------------------------------------------------------------------===// //===------------------------------------------------------------------===//
bool isDeclaration() { return isExternal(); } bool isDeclaration() { return isExternal(); }
}]; }];
let hasCustomAssemblyFormat = 1; let hasCustomAssemblyFormat = 1;
Show All 36 Lines

mlir/include/mlir/Dialect/GPU/GPUOps.td

Show First 20 Lines • Show All 215 Lines • ▼ Show 20 Lines ^bb0(%arg0: index, %workgroup: memref<32xf32, 3>,
"gpu.return"() : () -> () "gpu.return"() : () -> ()
}) : (index) -> () }) : (index) -> ()
``` ```
Note the non-default memory spaces used in memref types in memory Note the non-default memory spaces used in memref types in memory
attribution. attribution.
}]; }];
let arguments = (ins TypeAttrOf<FunctionType>:$function_type);
let regions = (region AnyRegion:$body); let regions = (region AnyRegion:$body);
let skipDefaultBuilders = 1; let skipDefaultBuilders = 1;
let builders = [ let builders = [
OpBuilder<(ins "StringRef":$name, "FunctionType":$type, OpBuilder<(ins "StringRef":$name, "FunctionType":$type,
CArg<"TypeRange", "{}">:$workgroupAttributions, CArg<"TypeRange", "{}">:$workgroupAttributions,
CArg<"TypeRange", "{}">:$privateAttributions, CArg<"TypeRange", "{}">:$privateAttributions,
Show All 13 Lines unsigned getNumWorkgroupAttributions() {
return (*this)->getAttrOfType<IntegerAttr>( return (*this)->getAttrOfType<IntegerAttr>(
getNumWorkgroupAttributionsAttrName()).getInt(); getNumWorkgroupAttributionsAttrName()).getInt();
} }
/// Returns a list of block arguments that correspond to buffers located in /// Returns a list of block arguments that correspond to buffers located in
/// the workgroup memory /// the workgroup memory
ArrayRef<BlockArgument> getWorkgroupAttributions() { ArrayRef<BlockArgument> getWorkgroupAttributions() {
auto begin = auto begin =
std::next(getBody().args_begin(), getType().getNumInputs()); std::next(getBody().args_begin(), getFunctionType().getNumInputs());
auto end = std::next(begin, getNumWorkgroupAttributions()); auto end = std::next(begin, getNumWorkgroupAttributions());
return {begin, end}; return {begin, end};
} }
/// Adds a new block argument that corresponds to buffers located in /// Adds a new block argument that corresponds to buffers located in
/// workgroup memory. /// workgroup memory.
BlockArgument addWorkgroupAttribution(Type type, Location loc); BlockArgument addWorkgroupAttribution(Type type, Location loc);
/// Returns the number of buffers located in the private memory. /// Returns the number of buffers located in the private memory.
unsigned getNumPrivateAttributions() { unsigned getNumPrivateAttributions() {
return getBody().getNumArguments() - getType().getNumInputs() - return getBody().getNumArguments() - getFunctionType().getNumInputs() -
getNumWorkgroupAttributions(); getNumWorkgroupAttributions();
} }
/// Returns a list of block arguments that correspond to buffers located in /// Returns a list of block arguments that correspond to buffers located in
/// the private memory. /// the private memory.
ArrayRef<BlockArgument> getPrivateAttributions() { ArrayRef<BlockArgument> getPrivateAttributions() {
// Buffers on the private memory always come after buffers on the workgroup // Buffers on the private memory always come after buffers on the workgroup
// memory. // memory.
auto begin = auto begin =
std::next(getBody().args_begin(), std::next(getBody().args_begin(),
getType().getNumInputs() + getNumWorkgroupAttributions()); getFunctionType().getNumInputs() + getNumWorkgroupAttributions());
return {begin, getBody().args_end()}; return {begin, getBody().args_end()};
} }
/// Adds a new block argument that corresponds to buffers located in /// Adds a new block argument that corresponds to buffers located in
/// private memory. /// private memory.
BlockArgument addPrivateAttribution(Type type, Location loc); BlockArgument addPrivateAttribution(Type type, Location loc);
/// Returns the name of the attribute containing the number of buffers /// Returns the name of the attribute containing the number of buffers
/// located in the workgroup memory. /// located in the workgroup memory.
static StringRef getNumWorkgroupAttributionsAttrName() { static StringRef getNumWorkgroupAttributionsAttrName() {
return "workgroup_attributions"; return "workgroup_attributions";
} }
/// Returns the type of this function. /// Returns the type of this function.
/// FIXME: We should drive this via the ODS `type` param. /// FIXME: Remove when GPU uses prefixed accessors.
FunctionType getType() { FunctionType getFunctionType() { return function_type(); }
return getTypeAttr().getValue().cast<FunctionType>();
}
/// Returns the argument types of this function. /// Returns the argument types of this function.
ArrayRef<Type> getArgumentTypes() { return getType().getInputs(); } ArrayRef<Type> getArgumentTypes() { return getFunctionType().getInputs(); }
/// Returns the result types of this function. /// Returns the result types of this function.
ArrayRef<Type> getResultTypes() { return getType().getResults(); } ArrayRef<Type> getResultTypes() { return getFunctionType().getResults(); }
/// Returns the keywords used in the custom syntax for this Op. /// Returns the keywords used in the custom syntax for this Op.
static StringRef getWorkgroupKeyword() { return "workgroup"; } static StringRef getWorkgroupKeyword() { return "workgroup"; }
static StringRef getPrivateKeyword() { return "private"; } static StringRef getPrivateKeyword() { return "private"; }
static StringRef getKernelKeyword() { return "kernel"; } static StringRef getKernelKeyword() { return "kernel"; }
/// Hook for FunctionOpInterface verifier. /// Hook for FunctionOpInterface verifier.
LogicalResult verifyType(); LogicalResult verifyType();
▲ Show 20 Lines • Show All 1,051 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/LLVMIR/LLVMOpBase.td

Show First 20 Lines • Show All 74 Lines • ▼ Show 20 Lines
// Type constraint accepting LLVM primitive types, i.e. all types except void // Type constraint accepting LLVM primitive types, i.e. all types except void
// and function. // and function.
def LLVM_PrimitiveType : Type< def LLVM_PrimitiveType : Type<
And<[LLVM_Type.predicate, And<[LLVM_Type.predicate,
CPred<"!$_self.isa<::mlir::LLVM::LLVMVoidType, " CPred<"!$_self.isa<::mlir::LLVM::LLVMVoidType, "
"::mlir::LLVM::LLVMFunctionType>()">]>, "::mlir::LLVM::LLVMFunctionType>()">]>,
"primitive LLVM type">; "primitive LLVM type">;
// Type constraint accepting any LLVM function type.
def LLVM_FunctionType : Type<CPred<"$_self.isa<::mlir::LLVM::LLVMFunctionType>()">,
"LLVM function type", "::mlir::LLVM::LLVMFunctionType">;
// Type constraint accepting any LLVM floating point type. // Type constraint accepting any LLVM floating point type.
def LLVM_AnyFloat : Type< def LLVM_AnyFloat : Type<
CPred<"::mlir::LLVM::isCompatibleFloatingPointType($_self)">, CPred<"::mlir::LLVM::isCompatibleFloatingPointType($_self)">,
"floating point LLVM type">; "floating point LLVM type">;
// Type constraint accepting any LLVM pointer type. // Type constraint accepting any LLVM pointer type.
def LLVM_AnyPointer : Type<CPred<"$_self.isa<::mlir::LLVM::LLVMPointerType>()">, def LLVM_AnyPointer : Type<CPred<"$_self.isa<::mlir::LLVM::LLVMPointerType>()">,
"LLVM pointer type">; "LLVM pointer type">;
▲ Show 20 Lines • Show All 274 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

Show First 20 Lines • Show All 531 Lines • ▼ Show 20 Linesdef LLVM_CallOp : LLVM_Op<"call",
}]; }];
let arguments = (ins OptionalAttr<FlatSymbolRefAttr>:$callee, let arguments = (ins OptionalAttr<FlatSymbolRefAttr>:$callee,
Variadic<LLVM_Type>, Variadic<LLVM_Type>,
DefaultValuedAttr<LLVM_FMFAttr, "{}">:$fastmathFlags); DefaultValuedAttr<LLVM_FMFAttr, "{}">:$fastmathFlags);
let results = (outs Variadic<LLVM_Type>); let results = (outs Variadic<LLVM_Type>);
let builders = [ let builders = [
OpBuilder<(ins "LLVMFuncOp":$func, "ValueRange":$operands, OpBuilder<(ins "LLVMFuncOp":$func, "ValueRange":$operands,
CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes), [{ CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes), [{
Type resultType = func.getType().getReturnType(); Type resultType = func.getFunctionType().getReturnType();
if (!resultType.isa<LLVM::LLVMVoidType>()) if (!resultType.isa<LLVM::LLVMVoidType>())
$_state.addTypes(resultType); $_state.addTypes(resultType);
$_state.addAttribute("callee", SymbolRefAttr::get(func)); $_state.addAttribute("callee", SymbolRefAttr::get(func));
$_state.addAttributes(attributes); $_state.addAttributes(attributes);
$_state.addOperands(operands); $_state.addOperands(operands);
}]>, }]>,
OpBuilder<(ins "TypeRange":$results, "StringAttr":$callee, OpBuilder<(ins "TypeRange":$results, "StringAttr":$callee,
CArg<"ValueRange", "{}">:$operands), [{ CArg<"ValueRange", "{}">:$operands), [{
▲ Show 20 Lines • Show All 320 Lines • ▼ Show 20 Lines [{
LLVM::LLVMPointerType::get(global.getType(), global.getAddrSpace()), LLVM::LLVMPointerType::get(global.getType(), global.getAddrSpace()),
global.getSymName()); global.getSymName());
$_state.addAttributes(attrs); $_state.addAttributes(attrs);
}]>, }]>,
OpBuilder<(ins "LLVMFuncOp":$func, OpBuilder<(ins "LLVMFuncOp":$func,
CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs), CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs),
[{ [{
build($_builder, $_state, build($_builder, $_state,
LLVM::LLVMPointerType::get(func.getType()), func.getName()); LLVM::LLVMPointerType::get(func.getFunctionType()), func.getName());
$_state.addAttributes(attrs); $_state.addAttributes(attrs);
}]> }]>
]; ];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
/// Return the llvm.mlir.global operation that defined the value referenced /// Return the llvm.mlir.global operation that defined the value referenced
/// here. /// here.
GlobalOp getGlobal(); GlobalOp getGlobal();
▲ Show 20 Lines • Show All 345 Lines • ▼ Show 20 Lines let description = [{
// A function with `internal` linkage. // A function with `internal` linkage.
llvm.func internal @internal_func() { llvm.func internal @internal_func() {
llvm.return llvm.return
} }
``` ```
}]; }];
let arguments = (ins DefaultValuedAttr<Linkage, "Linkage::External">:$linkage, let arguments = (ins
TypeAttrOf<LLVM_FunctionType>:$function_type,
DefaultValuedAttr<Linkage, "Linkage::External">:$linkage,
UnitAttr:$dso_local, UnitAttr:$dso_local,
OptionalAttr<FlatSymbolRefAttr>:$personality, OptionalAttr<FlatSymbolRefAttr>:$personality,
OptionalAttr<StrAttr>:$garbageCollector, OptionalAttr<StrAttr>:$garbageCollector,
OptionalAttr<ArrayAttr>:$passthrough); OptionalAttr<ArrayAttr>:$passthrough
);
let regions = (region AnyRegion:$body); let regions = (region AnyRegion:$body);
let skipDefaultBuilders = 1; let skipDefaultBuilders = 1;
let builders = [ let builders = [
OpBuilder<(ins "StringRef":$name, "Type":$type, OpBuilder<(ins "StringRef":$name, "Type":$type,
CArg<"Linkage", "Linkage::External">:$linkage, CArg<"Linkage", "Linkage::External">:$linkage,
CArg<"bool", "false">:$dsoLocal, CArg<"bool", "false">:$dsoLocal,
CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs, CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs,
CArg<"ArrayRef<DictionaryAttr>", "{}">:$argAttrs)> CArg<"ArrayRef<DictionaryAttr>", "{}">:$argAttrs)>
]; ];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
// Add an entry block to an empty function, and set up the block arguments // Add an entry block to an empty function, and set up the block arguments
// to match the signature of the function. // to match the signature of the function.
Block *addEntryBlock(); Block *addEntryBlock();
LLVMFunctionType getType() { bool isVarArg() { return getFunctionType().isVarArg(); }
return getTypeAttr().getValue().cast<LLVMFunctionType>();
}
bool isVarArg() { return getType().isVarArg(); }
/// Returns the argument types of this function. /// Returns the argument types of this function.
ArrayRef<Type> getArgumentTypes() { return getType().getParams(); } ArrayRef<Type> getArgumentTypes() { return getFunctionType().getParams(); }
/// Returns the result types of this function. /// Returns the result types of this function.
ArrayRef<Type> getResultTypes() { return getType().getReturnTypes(); } ArrayRef<Type> getResultTypes() { return getFunctionType().getReturnTypes(); }
/// Hook for FunctionOpInterface, called after verifying that the 'type'
/// attribute is present. This can check for preconditions of the
/// getNumArguments hook not failing.
LogicalResult verifyType();
}]; }];
let hasCustomAssemblyFormat = 1; let hasCustomAssemblyFormat = 1;
let hasVerifier = 1; let hasVerifier = 1;
let hasRegionVerifier = 1; let hasRegionVerifier = 1;
} }
def LLVM_NullOp def LLVM_NullOp
▲ Show 20 Lines • Show All 637 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/PDLInterp/IR/PDLInterpOps.td

Show First 20 Lines • Show All 651 Lines • ▼ Show 20 Lines pdl_interp.func @rewriter(%root: !pdl.operation) {
pdl_interp.erase %root pdl_interp.erase %root
pdl_interp.finalize pdl_interp.finalize
} }
``` ```
}]; }];
let arguments = (ins let arguments = (ins
SymbolNameAttr:$sym_name, SymbolNameAttr:$sym_name,
TypeAttrOf<FunctionType>:$type TypeAttrOf<FunctionType>:$function_type
); );
let regions = (region MinSizedRegion<1>:$body); let regions = (region MinSizedRegion<1>:$body);
// Create the function with the given name and type. This also automatically // Create the function with the given name and type. This also automatically
// inserts the entry block for the function. // inserts the entry block for the function.
let builders = [OpBuilder<(ins let builders = [OpBuilder<(ins
"StringRef":$name, "FunctionType":$type, "StringRef":$name, "FunctionType":$type,
CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs) CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)
>]; >];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
//===------------------------------------------------------------------===// //===------------------------------------------------------------------===//
// FunctionOpInterface Methods // FunctionOpInterface Methods
//===------------------------------------------------------------------===// //===------------------------------------------------------------------===//
/// Returns the argument types of this function. /// Returns the argument types of this function.
ArrayRef<Type> getArgumentTypes() { return getType().getInputs(); } ArrayRef<Type> getArgumentTypes() { return getFunctionType().getInputs(); }
/// Returns the result types of this function. /// Returns the result types of this function.
ArrayRef<Type> getResultTypes() { return getType().getResults(); } ArrayRef<Type> getResultTypes() { return getFunctionType().getResults(); }
}]; }];
let hasCustomAssemblyFormat = 1; let hasCustomAssemblyFormat = 1;
let skipDefaultBuilders = 1; let skipDefaultBuilders = 1;
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// pdl_interp::GetAttributeOp // pdl_interp::GetAttributeOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 623 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVStructureOps.td

Show First 20 Lines • Show All 281 Lines • ▼ Show 20 Lines let description = [{
```mlir ```mlir
spv.func @foo() -> () "None" { ... } spv.func @foo() -> () "None" { ... }
spv.func @bar() -> () "Inline|Pure" { ... } spv.func @bar() -> () "Inline|Pure" { ... }
``` ```
}]; }];
let arguments = (ins let arguments = (ins
TypeAttr:$type, TypeAttrOf<FunctionType>:$function_type,
StrAttr:$sym_name, StrAttr:$sym_name,
SPV_FunctionControlAttr:$function_control SPV_FunctionControlAttr:$function_control
); );
let results = (outs); let results = (outs);
let regions = (region AnyRegion:$body); let regions = (region AnyRegion:$body);
let hasVerifier = 0; let hasVerifier = 0;
let builders = [ let builders = [
OpBuilder<(ins "StringRef":$name, "FunctionType":$type, OpBuilder<(ins "StringRef":$name, "FunctionType":$type,
CArg<"spirv::FunctionControl", "spirv::FunctionControl::None">:$control, CArg<"spirv::FunctionControl", "spirv::FunctionControl::None">:$control,
CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>]; CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>];
let hasOpcode = 0; let hasOpcode = 0;
let autogenSerialization = 0; let autogenSerialization = 0;
let extraClassDeclaration = [{ let extraClassDeclaration = [{
/// Returns the type of this function. /// Returns the type of this function.
/// FIXME: We should drive this via the ODS `type` param. /// FIXME: Remove when SPIRV uses prefixed accessors.
FunctionType getType() { FunctionType getFunctionType() { return function_type(); }
return getTypeAttr().getValue().cast<FunctionType>();
}
/// Returns the argument types of this function. /// Returns the argument types of this function.
ArrayRef<Type> getArgumentTypes() { return getType().getInputs(); } ArrayRef<Type> getArgumentTypes() { return getFunctionType().getInputs(); }
/// Returns the result types of this function. /// Returns the result types of this function.
ArrayRef<Type> getResultTypes() { return getType().getResults(); } ArrayRef<Type> getResultTypes() { return getFunctionType().getResults(); }
/// Hook for FunctionOpInterface, called after verifying that the 'type' /// Hook for FunctionOpInterface, called after verifying that the 'type'
/// attribute is present and checks if it holds a function type. Ensures /// attribute is present and checks if it holds a function type. Ensures
/// getType, getNumArguments, and getNumResults can be called safely /// getType, getNumArguments, and getNumResults can be called safely
LogicalResult verifyType(); LogicalResult verifyType();
/// Hook for FunctionOpInterface, called after verifying the function /// Hook for FunctionOpInterface, called after verifying the function
/// type and the presence of the (potentially empty) function body. /// type and the presence of the (potentially empty) function body.
▲ Show 20 Lines • Show All 473 Lines • Show Last 20 Lines

mlir/include/mlir/IR/FunctionInterfaces.h

Show All 20 Lines
#include "llvm/ADT/BitVector.h" #include "llvm/ADT/BitVector.h"
#include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallString.h"
namespace mlir { namespace mlir {
namespace function_interface_impl { namespace function_interface_impl {
/// Return the name of the attribute used for function types. /// Return the name of the attribute used for function types.
inline StringRef getTypeAttrName() { return "type"; } inline StringRef getTypeAttrName() { return "function_type"; }
/// Return the name of the attribute used for function argument attributes. /// Return the name of the attribute used for function argument attributes.
inline StringRef getArgDictAttrName() { return "arg_attrs"; } inline StringRef getArgDictAttrName() { return "arg_attrs"; }
/// Return the name of the attribute used for function argument attributes. /// Return the name of the attribute used for function argument attributes.
inline StringRef getResultDictAttrName() { return "res_attrs"; } inline StringRef getResultDictAttrName() { return "res_attrs"; }
/// Returns the dictionary attribute corresponding to the argument at 'index'. /// Returns the dictionary attribute corresponding to the argument at 'index'.
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines op.setResultAttrs(index,
attributes.getDictionary(removedAttr.getContext())); attributes.getDictionary(removedAttr.getContext()));
return removedAttr; return removedAttr;
} }
/// This function defines the internal implementation of the `verifyTrait` /// This function defines the internal implementation of the `verifyTrait`
/// method on FunctionOpInterface::Trait. /// method on FunctionOpInterface::Trait.
template <typename ConcreteOp> template <typename ConcreteOp>
LogicalResult verifyTrait(ConcreteOp op) { LogicalResult verifyTrait(ConcreteOp op) {
if (!op.getTypeAttr()) if (!op.getFunctionTypeAttr())
return op.emitOpError("requires a type attribute '") return op.emitOpError("requires a type attribute '")
<< function_interface_impl::getTypeAttrName() << '\''; << function_interface_impl::getTypeAttrName() << '\'';
if (failed(op.verifyType())) if (failed(op.verifyType()))
return failure(); return failure();
if (ArrayAttr allArgAttrs = op.getAllArgAttrs()) { if (ArrayAttr allArgAttrs = op.getAllArgAttrs()) {
unsigned numArgs = op.getNumArguments(); unsigned numArgs = op.getNumArguments();
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

mlir/include/mlir/IR/FunctionInterfaces.td

Show All 31 Lines behave like functions. In particular, these operations:
* when this region is empty, the operation corresponds to an external * when this region is empty, the operation corresponds to an external
function. function.
* leading arguments of the first block of the region are treated as * leading arguments of the first block of the region are treated as
function arguments. function arguments.
The function, aside from implementing the various interface methods, The function, aside from implementing the various interface methods,
should have the following ODS arguments: should have the following ODS arguments:
- `type` (required) - `function_type` (required)
* A TypeAttr that holds the signature type of the function. * A TypeAttr that holds the signature type of the function.
* TODO: this field will soon be renamed to something less generic.
- `arg_attrs` (optional) - `arg_attrs` (optional)
* An ArrayAttr of DictionaryAttr that contains attribute dictionaries * An ArrayAttr of DictionaryAttr that contains attribute dictionaries
for each of the function arguments. for each of the function arguments.
- `res_attrs` (optional) - `res_attrs` (optional)
* An ArrayAttr of DictionaryAttr that contains attribute dictionaries * An ArrayAttr of DictionaryAttr that contains attribute dictionaries
for each of the function results. for each of the function results.
Show All 17 Lines InterfaceMethod<[{
Note: The default implementation assumes the function type has Note: The default implementation assumes the function type has
an appropriate clone method: an appropriate clone method:
`Type clone(ArrayRef<Type> inputs, ArrayRef<Type> results)` `Type clone(ArrayRef<Type> inputs, ArrayRef<Type> results)`
}], }],
"::mlir::Type", "cloneTypeWith", (ins "::mlir::Type", "cloneTypeWith", (ins
"::mlir::TypeRange":$inputs, "::mlir::TypeRange":$results "::mlir::TypeRange":$inputs, "::mlir::TypeRange":$results
), /*methodBody=*/[{}], /*defaultImplementation=*/[{ ), /*methodBody=*/[{}], /*defaultImplementation=*/[{
return $_op.getType().clone(inputs, results); return $_op.getFunctionType().clone(inputs, results);
}]>, }]>,
InterfaceMethod<[{ InterfaceMethod<[{
Verify the contents of the body of this function. Verify the contents of the body of this function.
Note: The default implementation merely checks that if the entry block Note: The default implementation merely checks that if the entry block
exists, it has the same number and type of arguments as the function type. exists, it has the same number and type of arguments as the function type.
}], }],
▲ Show 20 Lines • Show All 168 Lines • ▼ Show 20 Lines let extraSharedClassDeclaration = [{
} }
/// Returns the name of the attribute used for function argument attributes. /// Returns the name of the attribute used for function argument attributes.
static StringRef getResultDictAttrName() { static StringRef getResultDictAttrName() {
return function_interface_impl::getResultDictAttrName(); return function_interface_impl::getResultDictAttrName();
} }
/// Return the attribute containing the type of this function. /// Return the attribute containing the type of this function.
TypeAttr getTypeAttr() { TypeAttr getFunctionTypeAttr() {
return this->getOperation()->template getAttrOfType<TypeAttr>( return this->getOperation()->template getAttrOfType<TypeAttr>(
getTypeAttrName()); getTypeAttrName());
} }
/// Return the type of this function. /// Return the type of this function.
Type getType() { return getTypeAttr().getValue(); } Type getFunctionType() { return getFunctionTypeAttr().getValue(); }
//===------------------------------------------------------------------===// //===------------------------------------------------------------------===//
// Argument and Result Handling // Argument and Result Handling
//===------------------------------------------------------------------===// //===------------------------------------------------------------------===//
/// Returns the number of function arguments. /// Returns the number of function arguments.
unsigned getNumArguments() { return $_op.getArgumentTypes().size(); } unsigned getNumArguments() { return $_op.getArgumentTypes().size(); }
▲ Show 20 Lines • Show All 324 Lines • Show Last 20 Lines

mlir/include/mlir/IR/OpBase.td

Show First 20 Lines • Show All 1,263 Lines • ▼ Show 20 Linesclass TypeAttrBase<string retType, string summary> :
let convertFromStorage = "$_self.getValue().cast<" # retType # ">()"; let convertFromStorage = "$_self.getValue().cast<" # retType # ">()";
} }
def TypeAttr : TypeAttrBase<"::mlir::Type", "any type attribute"> { def TypeAttr : TypeAttrBase<"::mlir::Type", "any type attribute"> {
let constBuilderCall = "::mlir::TypeAttr::get($0)"; let constBuilderCall = "::mlir::TypeAttr::get($0)";
} }
class TypeAttrOf<Type ty> class TypeAttrOf<Type ty>
: TypeAttrBase<ty.cppClassName, "type attribute of " # ty.description> { : TypeAttrBase<ty.cppClassName, "type attribute of " # ty.summary> {
let constBuilderCall = "::mlir::TypeAttr::get($0)"; let constBuilderCall = "::mlir::TypeAttr::get($0)";
} }
// The mere presence of unit attributes has a meaning. Therefore, unit // The mere presence of unit attributes has a meaning. Therefore, unit
// attributes are always treated as optional and accessors to them return // attributes are always treated as optional and accessors to them return
// "true" if the attribute is present and "false" otherwise. // "true" if the attribute is present and "false" otherwise.
def UnitAttr : Attr<CPred<"$_self.isa<::mlir::UnitAttr>()">, "unit attribute"> { def UnitAttr : Attr<CPred<"$_self.isa<::mlir::UnitAttr>()">, "unit attribute"> {
let storageType = [{ ::mlir::UnitAttr }]; let storageType = [{ ::mlir::UnitAttr }];
▲ Show 20 Lines • Show All 1,407 Lines • Show Last 20 Lines

mlir/lib/Conversion/AsyncToLLVM/AsyncToLLVM.cpp

Show First 20 Lines • Show All 1,036 Lines • ▼ Show 20 Lines target.addLegalOp<arith::ConstantOp, func::ConstantOp,
UnrealizedConversionCastOp>(); UnrealizedConversionCastOp>();
target.addLegalDialect<LLVM::LLVMDialect>(); target.addLegalDialect<LLVM::LLVMDialect>();
// All operations from Async dialect must be lowered to the runtime API and // All operations from Async dialect must be lowered to the runtime API and
// LLVM intrinsics calls. // LLVM intrinsics calls.
target.addIllegalDialect<AsyncDialect>(); target.addIllegalDialect<AsyncDialect>();
// Add dynamic legality constraints to apply conversions defined above. // Add dynamic legality constraints to apply conversions defined above.
target.addDynamicallyLegalOp<FuncOp>( target.addDynamicallyLegalOp<FuncOp>([&](FuncOp op) {
[&](FuncOp op) { return converter.isSignatureLegal(op.getType()); }); return converter.isSignatureLegal(op.getFunctionType());
});
target.addDynamicallyLegalOp<func::ReturnOp>([&](func::ReturnOp op) { target.addDynamicallyLegalOp<func::ReturnOp>([&](func::ReturnOp op) {
return converter.isLegal(op.getOperandTypes()); return converter.isLegal(op.getOperandTypes());
}); });
target.addDynamicallyLegalOp<func::CallOp>([&](func::CallOp op) { target.addDynamicallyLegalOp<func::CallOp>([&](func::CallOp op) {
return converter.isSignatureLegal(op.getCalleeType()); return converter.isSignatureLegal(op.getCalleeType());
}); });
if (failed(applyPartialConversion(module, target, std::move(patterns)))) if (failed(applyPartialConversion(module, target, std::move(patterns))))
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

mlir/lib/Conversion/FuncToLLVM/FuncToLLVM.cpp

Show First 20 Lines • Show All 121 Lines • ▼ Show 20 Lines
/// Similarly, returned memrefs are passed via pointers to a C struct that is /// Similarly, returned memrefs are passed via pointers to a C struct that is
/// passed as additional argument. /// passed as additional argument.
/// Internally, the auxiliary function unpacks the descriptor into individual /// Internally, the auxiliary function unpacks the descriptor into individual
/// components and forwards them to `newFuncOp` and forwards the results to /// components and forwards them to `newFuncOp` and forwards the results to
/// the extra arguments. /// the extra arguments.
static void wrapForExternalCallers(OpBuilder &rewriter, Location loc, static void wrapForExternalCallers(OpBuilder &rewriter, Location loc,
LLVMTypeConverter &typeConverter, LLVMTypeConverter &typeConverter,
FuncOp funcOp, LLVM::LLVMFuncOp newFuncOp) { FuncOp funcOp, LLVM::LLVMFuncOp newFuncOp) {
auto type = funcOp.getType(); auto type = funcOp.getFunctionType();
SmallVector<NamedAttribute, 4> attributes; SmallVector<NamedAttribute, 4> attributes;
filterFuncAttributes(funcOp->getAttrs(), /*filterArgAndResAttrs=*/false, filterFuncAttributes(funcOp->getAttrs(), /*filterArgAndResAttrs=*/false,
attributes); attributes);
Type wrapperFuncType; Type wrapperFuncType;
bool resultIsNowArg; bool resultIsNowArg;
std::tie(wrapperFuncType, resultIsNowArg) = std::tie(wrapperFuncType, resultIsNowArg) =
typeConverter.convertFunctionTypeCWrapper(type); typeConverter.convertFunctionTypeCWrapper(type);
if (resultIsNowArg) if (resultIsNowArg)
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
static void wrapExternalFunction(OpBuilder &builder, Location loc, static void wrapExternalFunction(OpBuilder &builder, Location loc,
LLVMTypeConverter &typeConverter, LLVMTypeConverter &typeConverter,
FuncOp funcOp, LLVM::LLVMFuncOp newFuncOp) { FuncOp funcOp, LLVM::LLVMFuncOp newFuncOp) {
OpBuilder::InsertionGuard guard(builder); OpBuilder::InsertionGuard guard(builder);
Type wrapperType; Type wrapperType;
bool resultIsNowArg; bool resultIsNowArg;
std::tie(wrapperType, resultIsNowArg) = std::tie(wrapperType, resultIsNowArg) =
typeConverter.convertFunctionTypeCWrapper(funcOp.getType()); typeConverter.convertFunctionTypeCWrapper(funcOp.getFunctionType());
// This conversion can only fail if it could not convert one of the argument // This conversion can only fail if it could not convert one of the argument
// types. But since it has been applied to a non-wrapper function before, it // types. But since it has been applied to a non-wrapper function before, it
// should have failed earlier and not reach this point at all. // should have failed earlier and not reach this point at all.
assert(wrapperType && "unexpected type conversion failure"); assert(wrapperType && "unexpected type conversion failure");
SmallVector<NamedAttribute, 4> attributes; SmallVector<NamedAttribute, 4> attributes;
filterFuncAttributes(funcOp->getAttrs(), /*filterArgAndResAttrs=*/false, filterFuncAttributes(funcOp->getAttrs(), /*filterArgAndResAttrs=*/false,
attributes); attributes);
if (resultIsNowArg) if (resultIsNowArg)
prependResAttrsToArgAttrs(builder, attributes, funcOp.getNumArguments()); prependResAttrsToArgAttrs(builder, attributes, funcOp.getNumArguments());
// Create the auxiliary function. // Create the auxiliary function.
auto wrapperFunc = builder.create<LLVM::LLVMFuncOp>( auto wrapperFunc = builder.create<LLVM::LLVMFuncOp>(
loc, llvm::formatv("_mlir_ciface_{0}", funcOp.getName()).str(), loc, llvm::formatv("_mlir_ciface_{0}", funcOp.getName()).str(),
wrapperType, LLVM::Linkage::External, /*dsoLocal*/ false, attributes); wrapperType, LLVM::Linkage::External, /*dsoLocal*/ false, attributes);
builder.setInsertionPointToStart(newFuncOp.addEntryBlock()); builder.setInsertionPointToStart(newFuncOp.addEntryBlock());
// Get a ValueRange containing arguments. // Get a ValueRange containing arguments.
FunctionType type = funcOp.getType(); FunctionType type = funcOp.getFunctionType();
SmallVector<Value, 8> args; SmallVector<Value, 8> args;
args.reserve(type.getNumInputs()); args.reserve(type.getNumInputs());
ValueRange wrapperArgsRange(newFuncOp.getArguments()); ValueRange wrapperArgsRange(newFuncOp.getArguments());
if (resultIsNowArg) { if (resultIsNowArg) {
// Allocate the struct on the stack and pass the pointer. // Allocate the struct on the stack and pass the pointer.
Type resultType = Type resultType =
wrapperType.cast<LLVM::LLVMFunctionType>().getParamType(0); wrapperType.cast<LLVM::LLVMFunctionType>().getParamType(0);
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Linesprotected:
LLVM::LLVMFuncOp LLVM::LLVMFuncOp
convertFuncOpToLLVMFuncOp(FuncOp funcOp, convertFuncOpToLLVMFuncOp(FuncOp funcOp,
ConversionPatternRewriter &rewriter) const { ConversionPatternRewriter &rewriter) const {
// Convert the original function arguments. They are converted using the // Convert the original function arguments. They are converted using the
// LLVMTypeConverter provided to this legalization pattern. // LLVMTypeConverter provided to this legalization pattern.
auto varargsAttr = funcOp->getAttrOfType<BoolAttr>("func.varargs"); auto varargsAttr = funcOp->getAttrOfType<BoolAttr>("func.varargs");
TypeConverter::SignatureConversion result(funcOp.getNumArguments()); TypeConverter::SignatureConversion result(funcOp.getNumArguments());
auto llvmType = getTypeConverter()->convertFunctionSignature( auto llvmType = getTypeConverter()->convertFunctionSignature(
funcOp.getType(), varargsAttr && varargsAttr.getValue(), result); funcOp.getFunctionType(), varargsAttr && varargsAttr.getValue(),
result);
if (!llvmType) if (!llvmType)
return nullptr; return nullptr;
// Propagate argument/result attributes to all converted arguments/result // Propagate argument/result attributes to all converted arguments/result
// obtained after converting a given original argument/result. // obtained after converting a given original argument/result.
SmallVector<NamedAttribute, 4> attributes; SmallVector<NamedAttribute, 4> attributes;
filterFuncAttributes(funcOp->getAttrs(), /*filterArgAndResAttrs=*/true, filterFuncAttributes(funcOp->getAttrs(), /*filterArgAndResAttrs=*/true,
attributes); attributes);
▲ Show 20 Lines • Show All 96 Lines • ▼ Show 20 Lines matchAndRewrite(FuncOp funcOp, OpAdaptor adaptor,
// TODO: bare ptr conversion could be handled by argument materialization // TODO: bare ptr conversion could be handled by argument materialization
// and most of the code below would go away. But to do this, we would need a // and most of the code below would go away. But to do this, we would need a
// way to distinguish between FuncOp and other regions in the // way to distinguish between FuncOp and other regions in the
// addArgumentMaterialization hook. // addArgumentMaterialization hook.
// Store the type of memref-typed arguments before the conversion so that we // Store the type of memref-typed arguments before the conversion so that we
// can promote them to MemRef descriptor at the beginning of the function. // can promote them to MemRef descriptor at the beginning of the function.
SmallVector<Type, 8> oldArgTypes = SmallVector<Type, 8> oldArgTypes =
llvm::to_vector<8>(funcOp.getType().getInputs()); llvm::to_vector<8>(funcOp.getFunctionType().getInputs());
auto newFuncOp = convertFuncOpToLLVMFuncOp(funcOp, rewriter); auto newFuncOp = convertFuncOpToLLVMFuncOp(funcOp, rewriter);
if (!newFuncOp) if (!newFuncOp)
return failure(); return failure();
if (newFuncOp.getBody().empty()) { if (newFuncOp.getBody().empty()) {
rewriter.eraseOp(funcOp); rewriter.eraseOp(funcOp);
return success(); return success();
} }
▲ Show 20 Lines • Show All 335 Lines • Show Last 20 Lines

mlir/lib/Conversion/GPUCommon/GPUOpsLowering.cpp

Show All 35 Lines for (const auto &en : llvm::enumerate(gpuFuncOp.getWorkgroupAttributions())) {
auto globalOp = rewriter.create<LLVM::GlobalOp>( auto globalOp = rewriter.create<LLVM::GlobalOp>(
gpuFuncOp.getLoc(), arrayType, /*isConstant=*/false, gpuFuncOp.getLoc(), arrayType, /*isConstant=*/false,
LLVM::Linkage::Internal, name, /*value=*/Attribute(), LLVM::Linkage::Internal, name, /*value=*/Attribute(),
/*alignment=*/0, gpu::GPUDialect::getWorkgroupAddressSpace()); /*alignment=*/0, gpu::GPUDialect::getWorkgroupAddressSpace());
workgroupBuffers.push_back(globalOp); workgroupBuffers.push_back(globalOp);
} }
// Rewrite the original GPU function to an LLVM function. // Rewrite the original GPU function to an LLVM function.
auto funcType = typeConverter->convertType(gpuFuncOp.getType()) auto funcType = typeConverter->convertType(gpuFuncOp.getFunctionType())
.template cast<LLVM::LLVMPointerType>() .template cast<LLVM::LLVMPointerType>()
.getElementType(); .getElementType();
// Remap proper input types. // Remap proper input types.
TypeConverter::SignatureConversion signatureConversion( TypeConverter::SignatureConversion signatureConversion(
gpuFuncOp.front().getNumArguments()); gpuFuncOp.front().getNumArguments());
getTypeConverter()->convertFunctionSignature( getTypeConverter()->convertFunctionSignature(
gpuFuncOp.getType(), /*isVariadic=*/false, signatureConversion); gpuFuncOp.getFunctionType(), /*isVariadic=*/false, signatureConversion);
// Create the new function operation. Only copy those attributes that are // Create the new function operation. Only copy those attributes that are
// not specific to function modeling. // not specific to function modeling.
SmallVector<NamedAttribute, 4> attributes; SmallVector<NamedAttribute, 4> attributes;
for (const auto &attr : gpuFuncOp->getAttrs()) { for (const auto &attr : gpuFuncOp->getAttrs()) {
if (attr.getName() == SymbolTable::getSymbolAttrName() || if (attr.getName() == SymbolTable::getSymbolAttrName() ||
attr.getName() == FunctionOpInterface::getTypeAttrName() || attr.getName() == FunctionOpInterface::getTypeAttrName() ||
attr.getName() == gpu::GPUFuncOp::getNumWorkgroupAttributionsAttrName()) attr.getName() == gpu::GPUFuncOp::getNumWorkgroupAttributionsAttrName())
▲ Show 20 Lines • Show All 282 Lines • Show Last 20 Lines

mlir/lib/Conversion/GPUToSPIRV/GPUToSPIRV.cpp

Show First 20 Lines • Show All 178 Lines • ▼ Show 20 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Legalizes a GPU function as an entry SPIR-V function. // Legalizes a GPU function as an entry SPIR-V function.
static spirv::FuncOp static spirv::FuncOp
lowerAsEntryFunction(gpu::GPUFuncOp funcOp, TypeConverter &typeConverter, lowerAsEntryFunction(gpu::GPUFuncOp funcOp, TypeConverter &typeConverter,
ConversionPatternRewriter &rewriter, ConversionPatternRewriter &rewriter,
spirv::EntryPointABIAttr entryPointInfo, spirv::EntryPointABIAttr entryPointInfo,
ArrayRef<spirv::InterfaceVarABIAttr> argABIInfo) { ArrayRef<spirv::InterfaceVarABIAttr> argABIInfo) {
auto fnType = funcOp.getType(); auto fnType = funcOp.getFunctionType();
if (fnType.getNumResults()) { if (fnType.getNumResults()) {
funcOp.emitError("SPIR-V lowering only supports entry functions" funcOp.emitError("SPIR-V lowering only supports entry functions"
"with no return values right now"); "with no return values right now");
return nullptr; return nullptr;
} }
if (!argABIInfo.empty() && fnType.getNumInputs() != argABIInfo.size()) { if (!argABIInfo.empty() && fnType.getNumInputs() != argABIInfo.size()) {
funcOp.emitError( funcOp.emitError(
"lowering as entry functions requires ABI info for all arguments " "lowering as entry functions requires ABI info for all arguments "
"or none of them"); "or none of them");
return nullptr; return nullptr;
} }
// Update the signature to valid SPIR-V types and add the ABI // Update the signature to valid SPIR-V types and add the ABI
// attributes. These will be "materialized" by using the // attributes. These will be "materialized" by using the
// LowerABIAttributesPass. // LowerABIAttributesPass.
TypeConverter::SignatureConversion signatureConverter(fnType.getNumInputs()); TypeConverter::SignatureConversion signatureConverter(fnType.getNumInputs());
{ {
for (const auto &argType : enumerate(funcOp.getType().getInputs())) { for (const auto &argType :
enumerate(funcOp.getFunctionType().getInputs())) {
auto convertedType = typeConverter.convertType(argType.value()); auto convertedType = typeConverter.convertType(argType.value());
signatureConverter.addInputs(argType.index(), convertedType); signatureConverter.addInputs(argType.index(), convertedType);
} }
} }
auto newFuncOp = rewriter.create<spirv::FuncOp>( auto newFuncOp = rewriter.create<spirv::FuncOp>(
funcOp.getLoc(), funcOp.getName(), funcOp.getLoc(), funcOp.getName(),
rewriter.getFunctionType(signatureConverter.getConvertedTypes(), rewriter.getFunctionType(signatureConverter.getConvertedTypes(),
llvm::None)); llvm::None));
▲ Show 20 Lines • Show All 173 Lines • Show Last 20 Lines

mlir/lib/Conversion/LinalgToSPIRV/LinalgToSPIRVPass.cpp

Show All 32 Linesvoid LinalgToSPIRVPass::runOnOperation() {
SPIRVTypeConverter typeConverter(targetAttr); SPIRVTypeConverter typeConverter(targetAttr);
RewritePatternSet patterns(context); RewritePatternSet patterns(context);
populateLinalgToSPIRVPatterns(typeConverter, patterns); populateLinalgToSPIRVPatterns(typeConverter, patterns);
populateBuiltinFuncToSPIRVPatterns(typeConverter, patterns); populateBuiltinFuncToSPIRVPatterns(typeConverter, patterns);
// Allow builtin ops. // Allow builtin ops.
target->addLegalOp<ModuleOp>(); target->addLegalOp<ModuleOp>();
target->addDynamicallyLegalOp<FuncOp>([&](FuncOp op) { target->addDynamicallyLegalOp<FuncOp>([&](FuncOp op) {
return typeConverter.isSignatureLegal(op.getType()) && return typeConverter.isSignatureLegal(op.getFunctionType()) &&
typeConverter.isLegal(&op.getBody()); typeConverter.isLegal(&op.getBody());
}); });
if (failed(applyFullConversion(module, *target, std::move(patterns)))) if (failed(applyFullConversion(module, *target, std::move(patterns))))
return signalPassFailure(); return signalPassFailure();
} }
std::unique_ptr<OperationPass<ModuleOp>> mlir::createLinalgToSPIRVPass() { std::unique_ptr<OperationPass<ModuleOp>> mlir::createLinalgToSPIRVPass() {
return std::make_unique<LinalgToSPIRVPass>(); return std::make_unique<LinalgToSPIRVPass>();
} }

mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp

Show First 20 Lines • Show All 1,285 Lines • ▼ Show 20 Linespublic:
using SPIRVToLLVMConversion<spirv::FuncOp>::SPIRVToLLVMConversion; using SPIRVToLLVMConversion<spirv::FuncOp>::SPIRVToLLVMConversion;
LogicalResult LogicalResult
matchAndRewrite(spirv::FuncOp funcOp, OpAdaptor adaptor, matchAndRewrite(spirv::FuncOp funcOp, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const override { ConversionPatternRewriter &rewriter) const override {
// Convert function signature. At the moment LLVMType converter is enough // Convert function signature. At the moment LLVMType converter is enough
// for currently supported types. // for currently supported types.
auto funcType = funcOp.getType(); auto funcType = funcOp.getFunctionType();
TypeConverter::SignatureConversion signatureConverter( TypeConverter::SignatureConversion signatureConverter(
funcType.getNumInputs()); funcType.getNumInputs());
auto llvmType = typeConverter.convertFunctionSignature( auto llvmType = typeConverter.convertFunctionSignature(
funcOp.getType(), /*isVariadic=*/false, signatureConverter); funcType, /*isVariadic=*/false, signatureConverter);
if (!llvmType) if (!llvmType)
return failure(); return failure();
// Create a new `LLVMFuncOp` // Create a new `LLVMFuncOp`
Location loc = funcOp.getLoc(); Location loc = funcOp.getLoc();
StringRef name = funcOp.getName(); StringRef name = funcOp.getName();
auto newFuncOp = rewriter.create<LLVM::LLVMFuncOp>(loc, name, llvmType); auto newFuncOp = rewriter.create<LLVM::LLVMFuncOp>(loc, name, llvmType);
▲ Show 20 Lines • Show All 304 Lines • Show Last 20 Lines

mlir/lib/Dialect/Async/Transforms/AsyncParallelFor.cpp

Show First 20 Lines • Show All 457 Lines • ▼ Show 20 Lines
static FuncOp createAsyncDispatchFunction(ParallelComputeFunction &computeFunc, static FuncOp createAsyncDispatchFunction(ParallelComputeFunction &computeFunc,
PatternRewriter &rewriter) { PatternRewriter &rewriter) {
OpBuilder::InsertionGuard guard(rewriter); OpBuilder::InsertionGuard guard(rewriter);
Location loc = computeFunc.func.getLoc(); Location loc = computeFunc.func.getLoc();
ImplicitLocOpBuilder b(loc, rewriter); ImplicitLocOpBuilder b(loc, rewriter);
ModuleOp module = computeFunc.func->getParentOfType<ModuleOp>(); ModuleOp module = computeFunc.func->getParentOfType<ModuleOp>();
ArrayRef<Type> computeFuncInputTypes = computeFunc.func.getType().getInputs(); ArrayRef<Type> computeFuncInputTypes =
computeFunc.func.getFunctionType().getInputs();
// Compared to the parallel compute function async dispatch function takes // Compared to the parallel compute function async dispatch function takes
// additional !async.group argument. Also instead of a single `blockIndex` it // additional !async.group argument. Also instead of a single `blockIndex` it
// takes `blockStart` and `blockEnd` arguments to define the range of // takes `blockStart` and `blockEnd` arguments to define the range of
// dispatched blocks. // dispatched blocks.
SmallVector<Type> inputTypes; SmallVector<Type> inputTypes;
inputTypes.push_back(async::GroupType::get(rewriter.getContext())); inputTypes.push_back(async::GroupType::get(rewriter.getContext()));
inputTypes.push_back(rewriter.getIndexType()); // add blockStart argument inputTypes.push_back(rewriter.getIndexType()); // add blockStart argument
▲ Show 20 Lines • Show All 479 Lines • Show Last 20 Lines

mlir/lib/Dialect/Async/Transforms/AsyncToAsyncRuntime.cpp

Show First 20 Lines • Show All 608 Lines • ▼ Show 20 Lines
/// 4) Rewriting return ops as yield op and branch op into the suspend block. /// 4) Rewriting return ops as yield op and branch op into the suspend block.
static CoroMachinery rewriteFuncAsCoroutine(FuncOp func) { static CoroMachinery rewriteFuncAsCoroutine(FuncOp func) {
auto *ctx = func->getContext(); auto *ctx = func->getContext();
auto loc = func.getLoc(); auto loc = func.getLoc();
SmallVector<Type> resultTypes; SmallVector<Type> resultTypes;
resultTypes.reserve(func.getCallableResults().size()); resultTypes.reserve(func.getCallableResults().size());
llvm::transform(func.getCallableResults(), std::back_inserter(resultTypes), llvm::transform(func.getCallableResults(), std::back_inserter(resultTypes),
[](Type type) { return ValueType::get(type); }); [](Type type) { return ValueType::get(type); });
func.setType(FunctionType::get(ctx, func.getType().getInputs(), resultTypes)); func.setType(
FunctionType::get(ctx, func.getFunctionType().getInputs(), resultTypes));
func.insertResult(0, TokenType::get(ctx), {}); func.insertResult(0, TokenType::get(ctx), {});
for (Block &block : func.getBlocks()) { for (Block &block : func.getBlocks()) {
Operation *terminator = block.getTerminator(); Operation *terminator = block.getTerminator();
if (auto returnOp = dyn_cast<func::ReturnOp>(*terminator)) { if (auto returnOp = dyn_cast<func::ReturnOp>(*terminator)) {
ImplicitLocOpBuilder builder(loc, returnOp); ImplicitLocOpBuilder builder(loc, returnOp);
builder.create<YieldOp>(returnOp.getOperands()); builder.create<YieldOp>(returnOp.getOperands());
returnOp.erase(); returnOp.erase();
} }
▲ Show 20 Lines • Show All 196 Lines • Show Last 20 Lines

mlir/lib/Dialect/Bufferization/Transforms/BufferResultsToOutParams.cpp

Show All 14 Lines
using namespace mlir; using namespace mlir;
// Updates the func op and entry block. // Updates the func op and entry block.
// //
// Any args appended to the entry block are added to `appendedEntryArgs`. // Any args appended to the entry block are added to `appendedEntryArgs`.
static void updateFuncOp(FuncOp func, static void updateFuncOp(FuncOp func,
SmallVectorImpl<BlockArgument> &appendedEntryArgs) { SmallVectorImpl<BlockArgument> &appendedEntryArgs) {
auto functionType = func.getType(); auto functionType = func.getFunctionType();
// Collect information about the results will become appended arguments. // Collect information about the results will become appended arguments.
SmallVector<Type, 6> erasedResultTypes; SmallVector<Type, 6> erasedResultTypes;
BitVector erasedResultIndices(functionType.getNumResults()); BitVector erasedResultIndices(functionType.getNumResults());
for (const auto &resultType : llvm::enumerate(functionType.getResults())) { for (const auto &resultType : llvm::enumerate(functionType.getResults())) {
if (resultType.value().isa<BaseMemRefType>()) { if (resultType.value().isa<BaseMemRefType>()) {
erasedResultIndices.set(resultType.index()); erasedResultIndices.set(resultType.index());
erasedResultTypes.push_back(resultType.value()); erasedResultTypes.push_back(resultType.value());
▲ Show 20 Lines • Show All 116 Lines • Show Last 20 Lines

mlir/lib/Dialect/Func/IR/FuncOps.cpp

Show First 20 Lines • Show All 128 Lines • ▼ Show 20 LinesLogicalResult CallOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
if (!fnAttr) if (!fnAttr)
return emitOpError("requires a 'callee' symbol reference attribute"); return emitOpError("requires a 'callee' symbol reference attribute");
FuncOp fn = symbolTable.lookupNearestSymbolFrom<FuncOp>(*this, fnAttr); FuncOp fn = symbolTable.lookupNearestSymbolFrom<FuncOp>(*this, fnAttr);
if (!fn) if (!fn)
return emitOpError() << "'" << fnAttr.getValue() return emitOpError() << "'" << fnAttr.getValue()
<< "' does not reference a valid function"; << "' does not reference a valid function";
// Verify that the operand and result types match the callee. // Verify that the operand and result types match the callee.
auto fnType = fn.getType(); auto fnType = fn.getFunctionType();
if (fnType.getNumInputs() != getNumOperands()) if (fnType.getNumInputs() != getNumOperands())
return emitOpError("incorrect number of operands for callee"); return emitOpError("incorrect number of operands for callee");
for (unsigned i = 0, e = fnType.getNumInputs(); i != e; ++i) for (unsigned i = 0, e = fnType.getNumInputs(); i != e; ++i)
if (getOperand(i).getType() != fnType.getInput(i)) if (getOperand(i).getType() != fnType.getInput(i))
return emitOpError("operand type mismatch: expected operand type ") return emitOpError("operand type mismatch: expected operand type ")
<< fnType.getInput(i) << ", but provided " << fnType.getInput(i) << ", but provided "
<< getOperand(i).getType() << " for operand number " << i; << getOperand(i).getType() << " for operand number " << i;
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 LinesLogicalResult ConstantOp::verify() {
// Try to find the referenced function. // Try to find the referenced function.
auto fn = (*this)->getParentOfType<ModuleOp>().lookupSymbol<FuncOp>(fnName); auto fn = (*this)->getParentOfType<ModuleOp>().lookupSymbol<FuncOp>(fnName);
if (!fn) if (!fn)
return emitOpError() << "reference to undefined function '" << fnName return emitOpError() << "reference to undefined function '" << fnName
<< "'"; << "'";
// Check that the referenced function has the correct type. // Check that the referenced function has the correct type.
if (fn.getType() != type) if (fn.getFunctionType() != type)
return emitOpError("reference to function with mismatched type"); return emitOpError("reference to function with mismatched type");
return success(); return success();
} }
OpFoldResult ConstantOp::fold(ArrayRef<Attribute> operands) { OpFoldResult ConstantOp::fold(ArrayRef<Attribute> operands) {
assert(operands.empty() && "constant has no operands"); assert(operands.empty() && "constant has no operands");
return getValueAttr(); return getValueAttr();
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
FuncOp FuncOp::clone(BlockAndValueMapping &mapper) { FuncOp FuncOp::clone(BlockAndValueMapping &mapper) {
// Create the new function. // Create the new function.
FuncOp newFunc = cast<FuncOp>(getOperation()->cloneWithoutRegions()); FuncOp newFunc = cast<FuncOp>(getOperation()->cloneWithoutRegions());
// If the function has a body, then the user might be deleting arguments to // If the function has a body, then the user might be deleting arguments to
// the function by specifying them in the mapper. If so, we don't add the // the function by specifying them in the mapper. If so, we don't add the
// argument to the input type vector. // argument to the input type vector.
if (!isExternal()) { if (!isExternal()) {
FunctionType oldType = getType(); FunctionType oldType = getFunctionType();
unsigned oldNumArgs = oldType.getNumInputs(); unsigned oldNumArgs = oldType.getNumInputs();
SmallVector<Type, 4> newInputs; SmallVector<Type, 4> newInputs;
newInputs.reserve(oldNumArgs); newInputs.reserve(oldNumArgs);
for (unsigned i = 0; i != oldNumArgs; ++i) for (unsigned i = 0; i != oldNumArgs; ++i)
if (!mapper.contains(getArgument(i))) if (!mapper.contains(getArgument(i)))
newInputs.push_back(oldType.getInput(i)); newInputs.push_back(oldType.getInput(i));
Show All 26 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ReturnOp // ReturnOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
LogicalResult ReturnOp::verify() { LogicalResult ReturnOp::verify() {
auto function = cast<FuncOp>((*this)->getParentOp()); auto function = cast<FuncOp>((*this)->getParentOp());
// The operand number and types must match the function signature. // The operand number and types must match the function signature.
const auto &results = function.getType().getResults(); const auto &results = function.getFunctionType().getResults();
if (getNumOperands() != results.size()) if (getNumOperands() != results.size())
return emitOpError("has ") return emitOpError("has ")
<< getNumOperands() << " operands, but enclosing function (@" << getNumOperands() << " operands, but enclosing function (@"
<< function.getName() << ") returns " << results.size(); << function.getName() << ") returns " << results.size();
for (unsigned i = 0, e = results.size(); i != e; ++i) for (unsigned i = 0, e = results.size(); i != e; ++i)
if (getOperand(i).getType() != results[i]) if (getOperand(i).getType() != results[i])
return emitError() << "type of return operand " << i << " (" return emitError() << "type of return operand " << i << " ("
Show All 14 Lines

mlir/lib/Dialect/Func/Transforms/DecomposeCallGraphTypes.cpp

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Lines
struct DecomposeCallGraphTypesForFuncArgs struct DecomposeCallGraphTypesForFuncArgs
: public DecomposeCallGraphTypesOpConversionPattern<FuncOp> { : public DecomposeCallGraphTypesOpConversionPattern<FuncOp> {
using DecomposeCallGraphTypesOpConversionPattern:: using DecomposeCallGraphTypesOpConversionPattern::
DecomposeCallGraphTypesOpConversionPattern; DecomposeCallGraphTypesOpConversionPattern;
LogicalResult LogicalResult
matchAndRewrite(FuncOp op, OpAdaptor adaptor, matchAndRewrite(FuncOp op, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const final { ConversionPatternRewriter &rewriter) const final {
auto functionType = op.getType(); auto functionType = op.getFunctionType();
// Convert function arguments using the provided TypeConverter. // Convert function arguments using the provided TypeConverter.
TypeConverter::SignatureConversion conversion(functionType.getNumInputs()); TypeConverter::SignatureConversion conversion(functionType.getNumInputs());
for (const auto &argType : llvm::enumerate(functionType.getInputs())) { for (const auto &argType : llvm::enumerate(functionType.getInputs())) {
SmallVector<Type, 2> decomposedTypes; SmallVector<Type, 2> decomposedTypes;
if (failed(typeConverter->convertType(argType.value(), decomposedTypes))) if (failed(typeConverter->convertType(argType.value(), decomposedTypes)))
return failure(); return failure();
if (!decomposedTypes.empty()) if (!decomposedTypes.empty())
▲ Show 20 Lines • Show All 122 Lines • Show Last 20 Lines

mlir/lib/Dialect/Func/Transforms/FuncBufferize.cpp

Show All 29 Lines void runOnOperation() override {
bufferization::BufferizeTypeConverter typeConverter; bufferization::BufferizeTypeConverter typeConverter;
RewritePatternSet patterns(context); RewritePatternSet patterns(context);
ConversionTarget target(*context); ConversionTarget target(*context);
populateFunctionOpInterfaceTypeConversionPattern<FuncOp>(patterns, populateFunctionOpInterfaceTypeConversionPattern<FuncOp>(patterns,
typeConverter); typeConverter);
target.addDynamicallyLegalOp<FuncOp>([&](FuncOp op) { target.addDynamicallyLegalOp<FuncOp>([&](FuncOp op) {
return typeConverter.isSignatureLegal(op.getType()) && return typeConverter.isSignatureLegal(op.getFunctionType()) &&
typeConverter.isLegal(&op.getBody()); typeConverter.isLegal(&op.getBody());
}); });
populateCallOpTypeConversionPattern(patterns, typeConverter); populateCallOpTypeConversionPattern(patterns, typeConverter);
target.addDynamicallyLegalOp<CallOp>( target.addDynamicallyLegalOp<CallOp>(
[&](CallOp op) { return typeConverter.isLegal(op); }); [&](CallOp op) { return typeConverter.isLegal(op); });
populateBranchOpInterfaceTypeConversionPattern(patterns, typeConverter); populateBranchOpInterfaceTypeConversionPattern(patterns, typeConverter);
populateReturnOpTypeConversionPattern(patterns, typeConverter); populateReturnOpTypeConversionPattern(patterns, typeConverter);
Show All 19 Lines

mlir/lib/Dialect/GPU/IR/GPUDialect.cpp

Show First 20 Lines • Show All 255 Lines • ▼ Show 20 Lines auto walkResult = module.walk([&module](LaunchFuncOp launchOp) -> WalkResult {
unsigned actualNumArguments = launchOp.getNumKernelOperands(); unsigned actualNumArguments = launchOp.getNumKernelOperands();
unsigned expectedNumArguments = kernelGPUFunction.getNumArguments(); unsigned expectedNumArguments = kernelGPUFunction.getNumArguments();
if (expectedNumArguments != actualNumArguments) if (expectedNumArguments != actualNumArguments)
return launchOp.emitOpError("got ") return launchOp.emitOpError("got ")
<< actualNumArguments << " kernel operands but expected " << actualNumArguments << " kernel operands but expected "
<< expectedNumArguments; << expectedNumArguments;
auto functionType = kernelGPUFunction.getType(); auto functionType = kernelGPUFunction.getFunctionType();
for (unsigned i = 0; i < expectedNumArguments; ++i) { for (unsigned i = 0; i < expectedNumArguments; ++i) {
if (launchOp.getKernelOperand(i).getType() != functionType.getInput(i)) { if (launchOp.getKernelOperand(i).getType() != functionType.getInput(i)) {
return launchOp.emitOpError("type of function argument ") return launchOp.emitOpError("type of function argument ")
<< i << " does not match"; << i << " does not match";
} }
} }
return success(); return success();
▲ Show 20 Lines • Show All 445 Lines • ▼ Show 20 Lines
/// Adds a new block argument that corresponds to buffers located in /// Adds a new block argument that corresponds to buffers located in
/// workgroup memory. /// workgroup memory.
BlockArgument GPUFuncOp::addWorkgroupAttribution(Type type, Location loc) { BlockArgument GPUFuncOp::addWorkgroupAttribution(Type type, Location loc) {
auto attrName = getNumWorkgroupAttributionsAttrName(); auto attrName = getNumWorkgroupAttributionsAttrName();
auto attr = (*this)->getAttrOfType<IntegerAttr>(attrName); auto attr = (*this)->getAttrOfType<IntegerAttr>(attrName);
(*this)->setAttr(attrName, (*this)->setAttr(attrName,
IntegerAttr::get(attr.getType(), attr.getValue() + 1)); IntegerAttr::get(attr.getType(), attr.getValue() + 1));
return getBody().insertArgument(getType().getNumInputs() + attr.getInt(), return getBody().insertArgument(
type, loc); getFunctionType().getNumInputs() + attr.getInt(), type, loc);
} }
/// Adds a new block argument that corresponds to buffers located in /// Adds a new block argument that corresponds to buffers located in
/// private memory. /// private memory.
BlockArgument GPUFuncOp::addPrivateAttribution(Type type, Location loc) { BlockArgument GPUFuncOp::addPrivateAttribution(Type type, Location loc) {
// Buffers on the private memory always come after buffers on the workgroup // Buffers on the private memory always come after buffers on the workgroup
// memory. // memory.
return getBody().addArgument(type, loc); return getBody().addArgument(type, loc);
▲ Show 20 Lines • Show All 139 Lines • ▼ Show 20 Lines llvm::interleaveComma(
values, p, [&p](BlockArgument v) { p << v << " : " << v.getType(); }); values, p, [&p](BlockArgument v) { p << v << " : " << v.getType(); });
p << ')'; p << ')';
} }
void GPUFuncOp::print(OpAsmPrinter &p) { void GPUFuncOp::print(OpAsmPrinter &p) {
p << ' '; p << ' ';
p.printSymbolName(getName()); p.printSymbolName(getName());
FunctionType type = getType(); FunctionType type = getFunctionType();
function_interface_impl::printFunctionSignature(p, *this, type.getInputs(), function_interface_impl::printFunctionSignature(p, *this, type.getInputs(),
/*isVariadic=*/false, /*isVariadic=*/false,
type.getResults()); type.getResults());
printAttributions(p, getWorkgroupKeyword(), getWorkgroupAttributions()); printAttributions(p, getWorkgroupKeyword(), getWorkgroupAttributions());
printAttributions(p, getPrivateKeyword(), getPrivateAttributions()); printAttributions(p, getPrivateKeyword(), getPrivateAttributions());
if (isKernel()) if (isKernel())
p << ' ' << getKernelKeyword(); p << ' ' << getKernelKeyword();
function_interface_impl::printFunctionAttributes( function_interface_impl::printFunctionAttributes(
p, *this, type.getNumInputs(), type.getNumResults(), p, *this, type.getNumInputs(), type.getNumResults(),
{getNumWorkgroupAttributionsAttrName(), {getNumWorkgroupAttributionsAttrName(),
GPUDialect::getKernelFuncAttrName()}); GPUDialect::getKernelFuncAttrName()});
p << ' '; p << ' ';
p.printRegion(getBody(), /*printEntryBlockArgs=*/false); p.printRegion(getBody(), /*printEntryBlockArgs=*/false);
} }
LogicalResult GPUFuncOp::verifyType() { LogicalResult GPUFuncOp::verifyType() {
Type type = getTypeAttr().getValue(); Type type = getFunctionTypeAttr().getValue();
if (!type.isa<FunctionType>()) if (!type.isa<FunctionType>())
return emitOpError("requires '" + getTypeAttrName() + return emitOpError("requires '" + getTypeAttrName() +
"' attribute of function type"); "' attribute of function type");
if (isKernel() && getType().getNumResults() != 0) if (isKernel() && getFunctionType().getNumResults() != 0)
return emitOpError() << "expected void return type for kernel function"; return emitOpError() << "expected void return type for kernel function";
return success(); return success();
} }
static LogicalResult verifyAttributions(Operation *op, static LogicalResult verifyAttributions(Operation *op,
ArrayRef<BlockArgument> attributions, ArrayRef<BlockArgument> attributions,
unsigned memorySpace) { unsigned memorySpace) {
Show All 15 LinesLogicalResult GPUFuncOp::verifyBody() {
unsigned numFuncArguments = getNumArguments(); unsigned numFuncArguments = getNumArguments();
unsigned numWorkgroupAttributions = getNumWorkgroupAttributions(); unsigned numWorkgroupAttributions = getNumWorkgroupAttributions();
unsigned numBlockArguments = front().getNumArguments(); unsigned numBlockArguments = front().getNumArguments();
if (numBlockArguments < numFuncArguments + numWorkgroupAttributions) if (numBlockArguments < numFuncArguments + numWorkgroupAttributions)
return emitOpError() << "expected at least " return emitOpError() << "expected at least "
<< numFuncArguments + numWorkgroupAttributions << numFuncArguments + numWorkgroupAttributions
<< " arguments to body region"; << " arguments to body region";
ArrayRef<Type> funcArgTypes = getType().getInputs(); ArrayRef<Type> funcArgTypes = getFunctionType().getInputs();
for (unsigned i = 0; i < numFuncArguments; ++i) { for (unsigned i = 0; i < numFuncArguments; ++i) {
Type blockArgType = front().getArgument(i).getType(); Type blockArgType = front().getArgument(i).getType();
if (funcArgTypes[i] != blockArgType) if (funcArgTypes[i] != blockArgType)
return emitOpError() << "expected body region argument #" << i return emitOpError() << "expected body region argument #" << i
<< " to be of type " << funcArgTypes[i] << ", got " << " to be of type " << funcArgTypes[i] << ", got "
<< blockArgType; << blockArgType;
} }
if (failed(verifyAttributions(getOperation(), getWorkgroupAttributions(), if (failed(verifyAttributions(getOperation(), getWorkgroupAttributions(),
GPUDialect::getWorkgroupAddressSpace())) || GPUDialect::getWorkgroupAddressSpace())) ||
failed(verifyAttributions(getOperation(), getPrivateAttributions(), failed(verifyAttributions(getOperation(), getPrivateAttributions(),
GPUDialect::getPrivateAddressSpace()))) GPUDialect::getPrivateAddressSpace())))
return failure(); return failure();
return success(); return success();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ReturnOp // ReturnOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
LogicalResult gpu::ReturnOp::verify() { LogicalResult gpu::ReturnOp::verify() {
GPUFuncOp function = (*this)->getParentOfType<GPUFuncOp>(); GPUFuncOp function = (*this)->getParentOfType<GPUFuncOp>();
FunctionType funType = function.getType(); FunctionType funType = function.getFunctionType();
if (funType.getNumResults() != operands().size()) if (funType.getNumResults() != operands().size())
return emitOpError() return emitOpError()
.append("expected ", funType.getNumResults(), " result operands") .append("expected ", funType.getNumResults(), " result operands")
.attachNote(function.getLoc()) .attachNote(function.getLoc())
.append("return type declared here"); .append("return type declared here");
for (const auto &pair : llvm::enumerate( for (const auto &pair : llvm::enumerate(
llvm::zip(function.getType().getResults(), operands()))) { llvm::zip(function.getFunctionType().getResults(), operands()))) {
Type type; Type type;
Value operand; Value operand;
std::tie(type, operand) = pair.value(); std::tie(type, operand) = pair.value();
if (type != operand.getType()) if (type != operand.getType())
return emitOpError() << "unexpected type `" << operand.getType() return emitOpError() << "unexpected type `" << operand.getType()
<< "' for operand #" << pair.index(); << "' for operand #" << pair.index();
} }
return success(); return success();
▲ Show 20 Lines • Show All 292 Lines • Show Last 20 Lines

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

Show First 20 Lines • Show All 997 Lines • ▼ Show 20 Lines if (!callee)
return emitOpError() return emitOpError()
<< "'" << calleeName.getValue() << "'" << calleeName.getValue()
<< "' does not reference a symbol in the current scope"; << "' does not reference a symbol in the current scope";
auto fn = dyn_cast<LLVMFuncOp>(callee); auto fn = dyn_cast<LLVMFuncOp>(callee);
if (!fn) if (!fn)
return emitOpError() << "'" << calleeName.getValue() return emitOpError() << "'" << calleeName.getValue()
<< "' does not reference a valid LLVM function"; << "' does not reference a valid LLVM function";
fnType = fn.getType(); fnType = fn.getFunctionType();
} }
LLVMFunctionType funcType = fnType.dyn_cast<LLVMFunctionType>(); LLVMFunctionType funcType = fnType.dyn_cast<LLVMFunctionType>();
if (!funcType) if (!funcType)
return emitOpError("callee does not have a functional type: ") << fnType; return emitOpError("callee does not have a functional type: ") << fnType;
// Verify that the operand and result types match the callee. // Verify that the operand and result types match the callee.
▲ Show 20 Lines • Show All 479 Lines • ▼ Show 20 Lines
// Printing, parsing and verification for LLVM::ReturnOp. // Printing, parsing and verification for LLVM::ReturnOp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
LogicalResult ReturnOp::verify() { LogicalResult ReturnOp::verify() {
if (getNumOperands() > 1) if (getNumOperands() > 1)
return emitOpError("expected at most 1 operand"); return emitOpError("expected at most 1 operand");
if (auto parent = (*this)->getParentOfType<LLVMFuncOp>()) { if (auto parent = (*this)->getParentOfType<LLVMFuncOp>()) {
Type expectedType = parent.getType().getReturnType(); Type expectedType = parent.getFunctionType().getReturnType();
if (expectedType.isa<LLVMVoidType>()) { if (expectedType.isa<LLVMVoidType>()) {
if (getNumOperands() == 0) if (getNumOperands() == 0)
return success(); return success();
InFlightDiagnostic diag = emitOpError("expected no operands"); InFlightDiagnostic diag = emitOpError("expected no operands");
diag.attachNote(parent->getLoc()) << "when returning from function"; diag.attachNote(parent->getLoc()) << "when returning from function";
return diag; return diag;
} }
if (getNumOperands() == 0) { if (getNumOperands() == 0) {
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines return emitOpError(
"must reference a global defined by 'llvm.mlir.global' or 'llvm.func'"); "must reference a global defined by 'llvm.mlir.global' or 'llvm.func'");
if (global && if (global &&
LLVM::LLVMPointerType::get(global.getType(), global.getAddrSpace()) != LLVM::LLVMPointerType::get(global.getType(), global.getAddrSpace()) !=
getResult().getType()) getResult().getType())
return emitOpError( return emitOpError(
"the type must be a pointer to the type of the referenced global"); "the type must be a pointer to the type of the referenced global");
if (function && if (function && LLVM::LLVMPointerType::get(function.getFunctionType()) !=
LLVM::LLVMPointerType::get(function.getType()) != getResult().getType()) getResult().getType())
return emitOpError( return emitOpError(
"the type must be a pointer to the type of the referenced function"); "the type must be a pointer to the type of the referenced function");
return success(); return success();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Builder, printer and verifier for LLVM::GlobalOp. // Builder, printer and verifier for LLVM::GlobalOp.
▲ Show 20 Lines • Show All 376 Lines • ▼ Show 20 Lines
Block *LLVMFuncOp::addEntryBlock() { Block *LLVMFuncOp::addEntryBlock() {
assert(empty() && "function already has an entry block"); assert(empty() && "function already has an entry block");
assert(!isVarArg() && "unimplemented: non-external variadic functions"); assert(!isVarArg() && "unimplemented: non-external variadic functions");
auto *entry = new Block; auto *entry = new Block;
push_back(entry); push_back(entry);
// FIXME: Allow passing in proper locations for the entry arguments. // FIXME: Allow passing in proper locations for the entry arguments.
LLVMFunctionType type = getType(); LLVMFunctionType type = getFunctionType();
for (unsigned i = 0, e = type.getNumParams(); i < e; ++i) for (unsigned i = 0, e = type.getNumParams(); i < e; ++i)
entry->addArgument(type.getParamType(i), getLoc()); entry->addArgument(type.getParamType(i), getLoc());
return entry; return entry;
} }
void LLVMFuncOp::build(OpBuilder &builder, OperationState &result, void LLVMFuncOp::build(OpBuilder &builder, OperationState &result,
StringRef name, Type type, LLVM::Linkage linkage, StringRef name, Type type, LLVM::Linkage linkage,
bool dsoLocal, ArrayRef<NamedAttribute> attrs, bool dsoLocal, ArrayRef<NamedAttribute> attrs,
ArrayRef<DictionaryAttr> argAttrs) { ArrayRef<DictionaryAttr> argAttrs) {
result.addRegion(); result.addRegion();
result.addAttribute(SymbolTable::getSymbolAttrName(), result.addAttribute(SymbolTable::getSymbolAttrName(),
builder.getStringAttr(name)); builder.getStringAttr(name));
result.addAttribute("type", TypeAttr::get(type)); result.addAttribute(getFunctionTypeAttrName(result.name),
TypeAttr::get(type));
result.addAttribute(::getLinkageAttrName(), result.addAttribute(::getLinkageAttrName(),
LinkageAttr::get(builder.getContext(), linkage)); LinkageAttr::get(builder.getContext(), linkage));
result.attributes.append(attrs.begin(), attrs.end()); result.attributes.append(attrs.begin(), attrs.end());
if (dsoLocal) if (dsoLocal)
result.addAttribute("dso_local", builder.getUnitAttr()); result.addAttribute("dso_local", builder.getUnitAttr());
if (argAttrs.empty()) if (argAttrs.empty())
return; return;
▲ Show 20 Lines • Show All 94 Lines • ▼ Show 20 Lines
// helper functions. Drops "void" result since it cannot be parsed back. Skips // helper functions. Drops "void" result since it cannot be parsed back. Skips
// the external linkage since it is the default value. // the external linkage since it is the default value.
void LLVMFuncOp::print(OpAsmPrinter &p) { void LLVMFuncOp::print(OpAsmPrinter &p) {
p << ' '; p << ' ';
if (getLinkage() != LLVM::Linkage::External) if (getLinkage() != LLVM::Linkage::External)
p << stringifyLinkage(getLinkage()) << ' '; p << stringifyLinkage(getLinkage()) << ' ';
p.printSymbolName(getName()); p.printSymbolName(getName());
LLVMFunctionType fnType = getType(); LLVMFunctionType fnType = getFunctionType();
SmallVector<Type, 8> argTypes; SmallVector<Type, 8> argTypes;
SmallVector<Type, 1> resTypes; SmallVector<Type, 1> resTypes;
argTypes.reserve(fnType.getNumParams()); argTypes.reserve(fnType.getNumParams());
for (unsigned i = 0, e = fnType.getNumParams(); i < e; ++i) for (unsigned i = 0, e = fnType.getNumParams(); i < e; ++i)
argTypes.push_back(fnType.getParamType(i)); argTypes.push_back(fnType.getParamType(i));
Type returnType = fnType.getReturnType(); Type returnType = fnType.getReturnType();
if (!returnType.isa<LLVMVoidType>()) if (!returnType.isa<LLVMVoidType>())
resTypes.push_back(returnType); resTypes.push_back(returnType);
function_interface_impl::printFunctionSignature(p, *this, argTypes, function_interface_impl::printFunctionSignature(p, *this, argTypes,
isVarArg(), resTypes); isVarArg(), resTypes);
function_interface_impl::printFunctionAttributes( function_interface_impl::printFunctionAttributes(
p, *this, argTypes.size(), resTypes.size(), {getLinkageAttrName()}); p, *this, argTypes.size(), resTypes.size(), {getLinkageAttrName()});
// Print the body if this is not an external function. // Print the body if this is not an external function.
Region &body = getBody(); Region &body = getBody();
if (!body.empty()) { if (!body.empty()) {
p << ' '; p << ' ';
p.printRegion(body, /*printEntryBlockArgs=*/false, p.printRegion(body, /*printEntryBlockArgs=*/false,
/*printBlockTerminators=*/true); /*printBlockTerminators=*/true);
} }
} }
LogicalResult LLVMFuncOp::verifyType() {
auto llvmType = getTypeAttr().getValue().dyn_cast_or_null<LLVMFunctionType>();
if (!llvmType)
return emitOpError("requires '" + getTypeAttrName() +
"' attribute of wrapped LLVM function type");
return success();
}
// Verifies LLVM- and implementation-specific properties of the LLVM func Op: // Verifies LLVM- and implementation-specific properties of the LLVM func Op:
// - functions don't have 'common' linkage // - functions don't have 'common' linkage
// - external functions have 'external' or 'extern_weak' linkage; // - external functions have 'external' or 'extern_weak' linkage;
// - vararg is (currently) only supported for external functions; // - vararg is (currently) only supported for external functions;
LogicalResult LLVMFuncOp::verify() { LogicalResult LLVMFuncOp::verify() {
if (getLinkage() == LLVM::Linkage::Common) if (getLinkage() == LLVM::Linkage::Common)
return emitOpError() << "functions cannot have '" return emitOpError() << "functions cannot have '"
<< stringifyLinkage(LLVM::Linkage::Common) << stringifyLinkage(LLVM::Linkage::Common)
<< "' linkage"; << "' linkage";
// Check to see if this function has a void return with a result attribute to // Check to see if this function has a void return with a result attribute to
// it. It isn't clear what semantics we would assign to that. // it. It isn't clear what semantics we would assign to that.
if (getType().getReturnType().isa<LLVMVoidType>() && if (getFunctionType().getReturnType().isa<LLVMVoidType>() &&
!getResultAttrs(0).empty()) { !getResultAttrs(0).empty()) {
return emitOpError() return emitOpError()
<< "cannot attach result attributes to functions with a void return"; << "cannot attach result attributes to functions with a void return";
} }
if (isExternal()) { if (isExternal()) {
if (getLinkage() != LLVM::Linkage::External && if (getLinkage() != LLVM::Linkage::External &&
getLinkage() != LLVM::Linkage::ExternWeak) getLinkage() != LLVM::Linkage::ExternWeak)
Show All 12 Lines
} }
/// Verifies LLVM- and implementation-specific properties of the LLVM func Op: /// Verifies LLVM- and implementation-specific properties of the LLVM func Op:
/// - entry block arguments are of LLVM types. /// - entry block arguments are of LLVM types.
LogicalResult LLVMFuncOp::verifyRegions() { LogicalResult LLVMFuncOp::verifyRegions() {
if (isExternal()) if (isExternal())
return success(); return success();
unsigned numArguments = getType().getNumParams(); unsigned numArguments = getFunctionType().getNumParams();
Block &entryBlock = front(); Block &entryBlock = front();
for (unsigned i = 0; i < numArguments; ++i) { for (unsigned i = 0; i < numArguments; ++i) {
Type argType = entryBlock.getArgument(i).getType(); Type argType = entryBlock.getArgument(i).getType();
if (!isCompatibleType(argType)) if (!isCompatibleType(argType))
return emitOpError("entry block argument #") return emitOpError("entry block argument #")
<< i << " is not of LLVM type"; << i << " is not of LLVM type";
} }
▲ Show 20 Lines • Show All 806 Lines • Show Last 20 Lines

mlir/lib/Dialect/Linalg/ComprehensiveBufferize/ModuleBufferization.cpp

Show First 20 Lines • Show All 383 Lines • ▼ Show 20 Lines
/// future. /// future.
static LogicalResult bufferizeFuncOpBoundary(FuncOp funcOp, static LogicalResult bufferizeFuncOpBoundary(FuncOp funcOp,
RewriterBase &rewriter, RewriterBase &rewriter,
BufferizationState &state) { BufferizationState &state) {
const ModuleAnalysisState &moduleState = const ModuleAnalysisState &moduleState =
getModuleAnalysisState(state.getAnalysisState()); getModuleAnalysisState(state.getAnalysisState());
// If nothing to do then we are done. // If nothing to do then we are done.
if (!llvm::any_of(funcOp.getType().getInputs(), isaTensor) && if (!llvm::any_of(funcOp.getFunctionType().getInputs(), isaTensor) &&
!llvm::any_of(funcOp.getType().getResults(), isaTensor)) !llvm::any_of(funcOp.getFunctionType().getResults(), isaTensor))
return success(); return success();
// Get the bufferized FunctionType for funcOp or construct it if not yet // Get the bufferized FunctionType for funcOp or construct it if not yet
// available. // available.
// TODO: Atm we have 3 cases: // TODO: Atm we have 3 cases:
// 1. if a function is called from within the Module, it must have bufferized // 1. if a function is called from within the Module, it must have bufferized
// to inplaceable tensor results. // to inplaceable tensor results.
// 2. if it is bodiless, it must have bufferized and is not allowed to have // 2. if it is bodiless, it must have bufferized and is not allowed to have
// result tensors. // result tensors.
// 3. if it is not called internally, it still must bufferize to inplaceable // 3. if it is not called internally, it still must bufferize to inplaceable
// tensor results and we construct it now (e.g. top-level function called // tensor results and we construct it now (e.g. top-level function called
// externally). // externally).
// -> Figure out a better layering. // -> Figure out a better layering.
TypeRange resultTypes; TypeRange resultTypes;
// Corner case: Bodiless FuncOp // Corner case: Bodiless FuncOp
// ============================ // ============================
// The body of such functions is assumed opaque and we can't know the // The body of such functions is assumed opaque and we can't know the
// bufferization contract they want to enforce atm. // bufferization contract they want to enforce atm.
// As a consequence, only support functions that don't return any tensor atm. // As a consequence, only support functions that don't return any tensor atm.
if (funcOp.getBody().empty()) { if (funcOp.getBody().empty()) {
if (llvm::any_of(funcOp.getType().getResults(), isaTensor)) if (llvm::any_of(funcOp.getFunctionType().getResults(), isaTensor))
return funcOp->emitError() << "cannot bufferize bodiless function that " return funcOp->emitError() << "cannot bufferize bodiless function that "
<< "returns a tensor"; << "returns a tensor";
FunctionType bufferizedFuncType = getBufferizedFunctionType( FunctionType bufferizedFuncType = getBufferizedFunctionType(
funcOp.getContext(), funcOp.getType().getInputs(), TypeRange{}, funcOp.getContext(), funcOp.getFunctionType().getInputs(), TypeRange{},
state.getOptions()); state.getOptions());
funcOp.setType(bufferizedFuncType); funcOp.setType(bufferizedFuncType);
return success(); return success();
} }
// Support only single return-terminated block in the function. // Support only single return-terminated block in the function.
func::ReturnOp returnOp = getAssumedUniqueReturnOp(funcOp); func::ReturnOp returnOp = getAssumedUniqueReturnOp(funcOp);
assert(returnOp && "expected func with single return op"); assert(returnOp && "expected func with single return op");
Show All 18 Lines for (OpOperand &returnOperand : returnOp->getOpOperands()) {
// Cast values at the call site if necessary. // Cast values at the call site if necessary.
returnValues.push_back( returnValues.push_back(
getNonCastedValue(*state.getBuffer(rewriter, returnOperand))); getNonCastedValue(*state.getBuffer(rewriter, returnOperand)));
} }
// 2. Rewrite the terminator without the inPlace bufferizable values. // 2. Rewrite the terminator without the inPlace bufferizable values.
ValueRange retValues{returnValues}; ValueRange retValues{returnValues};
FunctionType bufferizedFuncType = getBufferizedFunctionType( FunctionType bufferizedFuncType = getBufferizedFunctionType(
funcOp.getContext(), funcOp.getType().getInputs(), retValues.getTypes(), funcOp.getContext(), funcOp.getFunctionType().getInputs(),
state.getOptions()); retValues.getTypes(), state.getOptions());
OpBuilder b(returnOp); OpBuilder b(returnOp);
b.create<func::ReturnOp>(returnOp.getLoc(), returnValues); b.create<func::ReturnOp>(returnOp.getLoc(), returnValues);
returnOp->erase(); returnOp->erase();
// 3. Rewrite the bbArgs. // 3. Rewrite the bbArgs.
// Iterate on the original `numArgs` and replace them in order. // Iterate on the original `numArgs` and replace them in order.
// This guarantees the argument order still matches after the rewrite. // This guarantees the argument order still matches after the rewrite.
Block &frontBlock = funcOp.getBody().front(); Block &frontBlock = funcOp.getBody().front();
▲ Show 20 Lines • Show All 129 Lines • ▼ Show 20 Lines for (FuncOp funcOp : orderedFuncOps) {
DenseMap<Operation *, SmallVector<Value>> operandsPerCaller; DenseMap<Operation *, SmallVector<Value>> operandsPerCaller;
foreachCaller(callerMap, funcOp, [&](Operation *caller) { foreachCaller(callerMap, funcOp, [&](Operation *caller) {
operandsPerCaller.try_emplace(caller, SmallVector<Value>()); operandsPerCaller.try_emplace(caller, SmallVector<Value>());
}); });
SmallVector<Type> argumentTypes; SmallVector<Type> argumentTypes;
// Iterate on each function argument and check it it was marked with a // Iterate on each function argument and check it it was marked with a
// desired layout. // desired layout.
for (const auto &it : llvm::enumerate(funcOp.getType().getInputs())) { for (const auto &it :
llvm::enumerate(funcOp.getFunctionType().getInputs())) {
int argNumber = it.index(); int argNumber = it.index();
Type inputType = it.value(); Type inputType = it.value();
auto memrefType = inputType.dyn_cast<MemRefType>(); auto memrefType = inputType.dyn_cast<MemRefType>();
auto layoutAttr = funcOp.getArgAttrOfType<AffineMapAttr>( auto layoutAttr = funcOp.getArgAttrOfType<AffineMapAttr>(
argNumber, BufferizableOpInterface::kBufferLayoutAttrName); argNumber, BufferizableOpInterface::kBufferLayoutAttrName);
AffineMap desiredLayoutMap = AffineMap desiredLayoutMap =
layoutAttr ? layoutAttr.getValue() : AffineMap(); layoutAttr ? layoutAttr.getValue() : AffineMap();
AffineMap currentLayoutMap = AffineMap currentLayoutMap =
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines for (FuncOp funcOp : orderedFuncOps) {
// Set operands with cast buffer on all callers to `funcOp`. // Set operands with cast buffer on all callers to `funcOp`.
foreachCaller(callerMap, funcOp, [&](Operation *caller) { foreachCaller(callerMap, funcOp, [&](Operation *caller) {
caller->setOperands(operandsPerCaller.lookup(caller)); caller->setOperands(operandsPerCaller.lookup(caller));
}); });
// Finally set the funcOp type to update the arguments. // Finally set the funcOp type to update the arguments.
auto newFuncType = FunctionType::get(moduleOp.getContext(), argumentTypes, auto newFuncType = FunctionType::get(moduleOp.getContext(), argumentTypes,
funcOp.getType().getResults()); funcOp.getFunctionType().getResults());
funcOp.setType(newFuncType); funcOp.setType(newFuncType);
} }
} }
namespace mlir { namespace mlir {
namespace linalg { namespace linalg {
namespace comprehensive_bufferize { namespace comprehensive_bufferize {
namespace std_ext { namespace std_ext {
▲ Show 20 Lines • Show All 368 Lines • ▼ Show 20 LinesLogicalResult mlir::linalg::comprehensive_bufferize::runModuleBufferize(
// Bufferize function boundaries. // Bufferize function boundaries.
for (FuncOp funcOp : moduleState.orderedFuncOps) { for (FuncOp funcOp : moduleState.orderedFuncOps) {
// Note: It would be good to apply cleanups here but we cannot as aliasInfo // Note: It would be good to apply cleanups here but we cannot as aliasInfo
// would be invalidated. // would be invalidated.
if (failed(bufferizeFuncOpBoundary(funcOp, rewriter, bufferizationState))) if (failed(bufferizeFuncOpBoundary(funcOp, rewriter, bufferizationState)))
return failure(); return failure();
if (!options.allowReturnAllocs && if (!options.allowReturnAllocs &&
llvm::any_of(funcOp.getType().getResults(), [](Type t) { llvm::any_of(funcOp.getFunctionType().getResults(), [](Type t) {
return t.isa<MemRefType, UnrankedMemRefType>(); return t.isa<MemRefType, UnrankedMemRefType>();
})) { })) {
funcOp->emitError("memref return type is unsupported"); funcOp->emitError("memref return type is unsupported");
return failure(); return failure();
} }
} }
// Finalize all buffers. // Finalize all buffers.
Show All 15 Lines

mlir/lib/Dialect/MemRef/Transforms/NormalizeMemRefs.cpp

Show First 20 Lines • Show All 187 Lines • ▼ Show 20 Lines
/// Fetch the updated argument list and result of the function and update the /// Fetch the updated argument list and result of the function and update the
/// function signature. This updates the function's return type at the caller /// function signature. This updates the function's return type at the caller
/// site and in case the return type is a normalized memref then it updates /// site and in case the return type is a normalized memref then it updates
/// the calling function's signature. /// the calling function's signature.
/// TODO: An update to the calling function signature is required only if the /// TODO: An update to the calling function signature is required only if the
/// returned value is in turn used in ReturnOp of the calling function. /// returned value is in turn used in ReturnOp of the calling function.
void NormalizeMemRefs::updateFunctionSignature(FuncOp funcOp, void NormalizeMemRefs::updateFunctionSignature(FuncOp funcOp,
ModuleOp moduleOp) { ModuleOp moduleOp) {
FunctionType functionType = funcOp.getType(); FunctionType functionType = funcOp.getFunctionType();
SmallVector<Type, 4> resultTypes; SmallVector<Type, 4> resultTypes;
FunctionType newFuncType; FunctionType newFuncType;
resultTypes = llvm::to_vector<4>(functionType.getResults()); resultTypes = llvm::to_vector<4>(functionType.getResults());
// External function's signature was already updated in // External function's signature was already updated in
// 'normalizeFuncOpMemRefs()'. // 'normalizeFuncOpMemRefs()'.
if (!funcOp.isExternal()) { if (!funcOp.isExternal()) {
SmallVector<Type, 8> argTypes; SmallVector<Type, 8> argTypes;
▲ Show 20 Lines • Show All 123 Lines • ▼ Show 20 Linesvoid NormalizeMemRefs::normalizeFuncOpMemRefs(FuncOp funcOp,
SmallVector<memref::AllocOp, 4> allocOps; SmallVector<memref::AllocOp, 4> allocOps;
funcOp.walk([&](memref::AllocOp op) { allocOps.push_back(op); }); funcOp.walk([&](memref::AllocOp op) { allocOps.push_back(op); });
for (memref::AllocOp allocOp : allocOps) for (memref::AllocOp allocOp : allocOps)
(void)normalizeMemRef(&allocOp); (void)normalizeMemRef(&allocOp);
// We use this OpBuilder to create new memref layout later. // We use this OpBuilder to create new memref layout later.
OpBuilder b(funcOp); OpBuilder b(funcOp);
FunctionType functionType = funcOp.getType(); FunctionType functionType = funcOp.getFunctionType();
SmallVector<Location> functionArgLocs(llvm::map_range( SmallVector<Location> functionArgLocs(llvm::map_range(
funcOp.getArguments(), [](BlockArgument arg) { return arg.getLoc(); })); funcOp.getArguments(), [](BlockArgument arg) { return arg.getLoc(); }));
SmallVector<Type, 8> inputTypes; SmallVector<Type, 8> inputTypes;
// Walk over each argument of a function to perform memref normalization (if // Walk over each argument of a function to perform memref normalization (if
for (unsigned argIndex : for (unsigned argIndex :
llvm::seq<unsigned>(0, functionType.getNumInputs())) { llvm::seq<unsigned>(0, functionType.getNumInputs())) {
Type argType = functionType.getInput(argIndex); Type argType = functionType.getInput(argIndex);
MemRefType memrefType = argType.dyn_cast<MemRefType>(); MemRefType memrefType = argType.dyn_cast<MemRefType>();
▲ Show 20 Lines • Show All 179 Lines • Show Last 20 Lines

mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp

Show First 20 Lines • Show All 2,239 Lines • ▼ Show 20 Lines OptionalParseResult result = parser.parseOptionalRegion(
*body, entryArgs, entryArgs.empty() ? ArrayRef<Type>() : argTypes); *body, entryArgs, entryArgs.empty() ? ArrayRef<Type>() : argTypes);
return failure(result.hasValue() && failed(*result)); return failure(result.hasValue() && failed(*result));
} }
void spirv::FuncOp::print(OpAsmPrinter &printer) { void spirv::FuncOp::print(OpAsmPrinter &printer) {
// Print function name, signature, and control. // Print function name, signature, and control.
printer << " "; printer << " ";
printer.printSymbolName(sym_name()); printer.printSymbolName(sym_name());
auto fnType = getType(); auto fnType = getFunctionType();
function_interface_impl::printFunctionSignature( function_interface_impl::printFunctionSignature(
printer, *this, fnType.getInputs(), printer, *this, fnType.getInputs(),
/*isVariadic=*/false, fnType.getResults()); /*isVariadic=*/false, fnType.getResults());
printer << " \"" << spirv::stringifyFunctionControl(function_control()) printer << " \"" << spirv::stringifyFunctionControl(function_control())
<< "\""; << "\"";
function_interface_impl::printFunctionAttributes( function_interface_impl::printFunctionAttributes(
printer, *this, fnType.getNumInputs(), fnType.getNumResults(), printer, *this, fnType.getNumInputs(), fnType.getNumResults(),
{spirv::attributeName<spirv::FunctionControl>()}); {spirv::attributeName<spirv::FunctionControl>()});
// Print the body if this is not an external function. // Print the body if this is not an external function.
Region &body = this->body(); Region &body = this->body();
if (!body.empty()) { if (!body.empty()) {
printer << ' '; printer << ' ';
printer.printRegion(body, /*printEntryBlockArgs=*/false, printer.printRegion(body, /*printEntryBlockArgs=*/false,
/*printBlockTerminators=*/true); /*printBlockTerminators=*/true);
} }
} }
LogicalResult spirv::FuncOp::verifyType() { LogicalResult spirv::FuncOp::verifyType() {
auto type = getTypeAttr().getValue(); auto type = getFunctionTypeAttr().getValue();
if (!type.isa<FunctionType>()) if (!type.isa<FunctionType>())
return emitOpError("requires '" + getTypeAttrName() + return emitOpError("requires '" + getTypeAttrName() +
"' attribute of function type"); "' attribute of function type");
if (getType().getNumResults() > 1) if (getFunctionType().getNumResults() > 1)
return emitOpError("cannot have more than one result"); return emitOpError("cannot have more than one result");
return success(); return success();
} }
LogicalResult spirv::FuncOp::verifyBody() { LogicalResult spirv::FuncOp::verifyBody() {
FunctionType fnType = getType(); FunctionType fnType = getFunctionType();
auto walkResult = walk([fnType](Operation *op) -> WalkResult { auto walkResult = walk([fnType](Operation *op) -> WalkResult {
if (auto retOp = dyn_cast<spirv::ReturnOp>(op)) { if (auto retOp = dyn_cast<spirv::ReturnOp>(op)) {
if (fnType.getNumResults() != 0) if (fnType.getNumResults() != 0)
return retOp.emitOpError("cannot be used in functions returning value"); return retOp.emitOpError("cannot be used in functions returning value");
} else if (auto retOp = dyn_cast<spirv::ReturnValueOp>(op)) { } else if (auto retOp = dyn_cast<spirv::ReturnValueOp>(op)) {
if (fnType.getNumResults() != 1) if (fnType.getNumResults() != 1)
return retOp.emitOpError( return retOp.emitOpError(
Show All 30 Lines
// CallableOpInterface // CallableOpInterface
Region *spirv::FuncOp::getCallableRegion() { Region *spirv::FuncOp::getCallableRegion() {
return isExternal() ? nullptr : &body(); return isExternal() ? nullptr : &body();
} }
// CallableOpInterface // CallableOpInterface
ArrayRef<Type> spirv::FuncOp::getCallableResults() { ArrayRef<Type> spirv::FuncOp::getCallableResults() {
return getType().getResults(); return getFunctionType().getResults();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.FunctionCall // spv.FunctionCall
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
LogicalResult spirv::FunctionCallOp::verify() { LogicalResult spirv::FunctionCallOp::verify() {
auto fnName = calleeAttr(); auto fnName = calleeAttr();
auto funcOp = dyn_cast_or_null<spirv::FuncOp>( auto funcOp = dyn_cast_or_null<spirv::FuncOp>(
SymbolTable::lookupNearestSymbolFrom((*this)->getParentOp(), fnName)); SymbolTable::lookupNearestSymbolFrom((*this)->getParentOp(), fnName));
if (!funcOp) { if (!funcOp) {
return emitOpError("callee function '") return emitOpError("callee function '")
<< fnName.getValue() << "' not found in nearest symbol table"; << fnName.getValue() << "' not found in nearest symbol table";
} }
auto functionType = funcOp.getType(); auto functionType = funcOp.getFunctionType();
if (getNumResults() > 1) { if (getNumResults() > 1) {
return emitOpError( return emitOpError(
"expected callee function to have 0 or 1 result, but provided ") "expected callee function to have 0 or 1 result, but provided ")
<< getNumResults(); << getNumResults();
} }
if (functionType.getNumInputs() != getNumOperands()) { if (functionType.getNumInputs() != getNumOperands()) {
▲ Show 20 Lines • Show All 2,104 Lines • Show Last 20 Lines

mlir/lib/Dialect/SPIRV/Transforms/LowerABIAttributesPass.cpp

Show All 33 LinescreateGlobalVarForEntryPointArgument(OpBuilder &builder, spirv::FuncOp funcOp,
OpBuilder::InsertionGuard moduleInsertionGuard(builder); OpBuilder::InsertionGuard moduleInsertionGuard(builder);
builder.setInsertionPoint(funcOp.getOperation()); builder.setInsertionPoint(funcOp.getOperation());
std::string varName = std::string varName =
funcOp.getName().str() + "_arg_" + std::to_string(argIndex); funcOp.getName().str() + "_arg_" + std::to_string(argIndex);
// Get the type of variable. If this is a scalar/vector type and has an ABI // Get the type of variable. If this is a scalar/vector type and has an ABI
// info create a variable of type !spv.ptr<!spv.struct<elementType>>. If not // info create a variable of type !spv.ptr<!spv.struct<elementType>>. If not
// it must already be a !spv.ptr<!spv.struct<...>>. // it must already be a !spv.ptr<!spv.struct<...>>.
auto varType = funcOp.getType().getInput(argIndex); auto varType = funcOp.getFunctionType().getInput(argIndex);
if (varType.cast<spirv::SPIRVType>().isScalarOrVector()) { if (varType.cast<spirv::SPIRVType>().isScalarOrVector()) {
auto storageClass = abiInfo.getStorageClass(); auto storageClass = abiInfo.getStorageClass();
if (!storageClass) if (!storageClass)
return nullptr; return nullptr;
varType = varType =
spirv::PointerType::get(spirv::StructType::get(varType), *storageClass); spirv::PointerType::get(spirv::StructType::get(varType), *storageClass);
} }
auto varPtrType = varType.cast<spirv::PointerType>(); auto varPtrType = varType.cast<spirv::PointerType>();
▲ Show 20 Lines • Show All 123 Lines • ▼ Show 20 LinesLogicalResult ProcessInterfaceVarABI::matchAndRewrite(
spirv::FuncOp funcOp, OpAdaptor adaptor, spirv::FuncOp funcOp, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const { ConversionPatternRewriter &rewriter) const {
if (!funcOp->getAttrOfType<spirv::EntryPointABIAttr>( if (!funcOp->getAttrOfType<spirv::EntryPointABIAttr>(
spirv::getEntryPointABIAttrName())) { spirv::getEntryPointABIAttrName())) {
// TODO: Non-entry point functions are not handled. // TODO: Non-entry point functions are not handled.
return failure(); return failure();
} }
TypeConverter::SignatureConversion signatureConverter( TypeConverter::SignatureConversion signatureConverter(
funcOp.getType().getNumInputs()); funcOp.getFunctionType().getNumInputs());
auto &typeConverter = *getTypeConverter<SPIRVTypeConverter>(); auto &typeConverter = *getTypeConverter<SPIRVTypeConverter>();
auto indexType = typeConverter.getIndexType(); auto indexType = typeConverter.getIndexType();
auto attrName = spirv::getInterfaceVarABIAttrName(); auto attrName = spirv::getInterfaceVarABIAttrName();
for (const auto &argType : llvm::enumerate(funcOp.getType().getInputs())) { for (const auto &argType :
llvm::enumerate(funcOp.getFunctionType().getInputs())) {
auto abiInfo = funcOp.getArgAttrOfType<spirv::InterfaceVarABIAttr>( auto abiInfo = funcOp.getArgAttrOfType<spirv::InterfaceVarABIAttr>(
argType.index(), attrName); argType.index(), attrName);
if (!abiInfo) { if (!abiInfo) {
// TODO: For non-entry point functions, it should be legal // TODO: For non-entry point functions, it should be legal
// to pass around scalar/vector values and return a scalar/vector. For now // to pass around scalar/vector values and return a scalar/vector. For now
// non-entry point functions are not handled in this ABI lowering and will // non-entry point functions are not handled in this ABI lowering and will
// produce an error. // produce an error.
return failure(); return failure();
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

mlir/lib/Dialect/SPIRV/Transforms/SPIRVConversion.cpp

Show First 20 Lines • Show All 547 Lines • ▼ Show 20 Linespublic:
matchAndRewrite(FuncOp funcOp, OpAdaptor adaptor, matchAndRewrite(FuncOp funcOp, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const override; ConversionPatternRewriter &rewriter) const override;
}; };
} // namespace } // namespace
LogicalResult LogicalResult
FuncOpConversion::matchAndRewrite(FuncOp funcOp, OpAdaptor adaptor, FuncOpConversion::matchAndRewrite(FuncOp funcOp, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const { ConversionPatternRewriter &rewriter) const {
auto fnType = funcOp.getType(); auto fnType = funcOp.getFunctionType();
if (fnType.getNumResults() > 1) if (fnType.getNumResults() > 1)
return failure(); return failure();
TypeConverter::SignatureConversion signatureConverter(fnType.getNumInputs()); TypeConverter::SignatureConversion signatureConverter(fnType.getNumInputs());
for (const auto &argType : enumerate(fnType.getInputs())) { for (const auto &argType : enumerate(fnType.getInputs())) {
auto convertedType = getTypeConverter()->convertType(argType.value()); auto convertedType = getTypeConverter()->convertType(argType.value());
if (!convertedType) if (!convertedType)
return failure(); return failure();
▲ Show 20 Lines • Show All 351 Lines • Show Last 20 Lines

mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorPasses.cpp

Show First 20 Lines • Show All 77 Lines • ▼ Show 20 Lines void runOnOperation() override {
RewritePatternSet patterns(ctx); RewritePatternSet patterns(ctx);
SparseTensorTypeConverter converter; SparseTensorTypeConverter converter;
ConversionTarget target(*ctx); ConversionTarget target(*ctx);
// Everything in the sparse dialect must go! // Everything in the sparse dialect must go!
target.addIllegalDialect<SparseTensorDialect>(); target.addIllegalDialect<SparseTensorDialect>();
// All dynamic rules below accept new function, call, return, and tensor // All dynamic rules below accept new function, call, return, and tensor
// dim and cast operations as legal output of the rewriting provided that // dim and cast operations as legal output of the rewriting provided that
// all sparse tensor types have been fully rewritten. // all sparse tensor types have been fully rewritten.
target.addDynamicallyLegalOp<FuncOp>( target.addDynamicallyLegalOp<FuncOp>([&](FuncOp op) {
[&](FuncOp op) { return converter.isSignatureLegal(op.getType()); }); return converter.isSignatureLegal(op.getFunctionType());
});
target.addDynamicallyLegalOp<func::CallOp>([&](func::CallOp op) { target.addDynamicallyLegalOp<func::CallOp>([&](func::CallOp op) {
return converter.isSignatureLegal(op.getCalleeType()); return converter.isSignatureLegal(op.getCalleeType());
}); });
target.addDynamicallyLegalOp<func::ReturnOp>([&](func::ReturnOp op) { target.addDynamicallyLegalOp<func::ReturnOp>([&](func::ReturnOp op) {
return converter.isLegal(op.getOperandTypes()); return converter.isLegal(op.getOperandTypes());
}); });
target.addDynamicallyLegalOp<tensor::DimOp>([&](tensor::DimOp op) { target.addDynamicallyLegalOp<tensor::DimOp>([&](tensor::DimOp op) {
return converter.isLegal(op.getOperandTypes()); return converter.isLegal(op.getOperandTypes());
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

mlir/lib/Dialect/Tosa/Transforms/TosaInferShapes.cpp

Show First 20 Lines • Show All 287 Lines • ▼ Show 20 Lines void runOnOperation() override {
// Insert UnrealizedConversionCasts to guarantee ReturnOp agress with // Insert UnrealizedConversionCasts to guarantee ReturnOp agress with
// the FuncOp type. // the FuncOp type.
func.walk([&](func::ReturnOp op) { func.walk([&](func::ReturnOp op) {
FuncOp parent = dyn_cast<FuncOp>(op->getParentOp()); FuncOp parent = dyn_cast<FuncOp>(op->getParentOp());
if (!parent) if (!parent)
return; return;
rewriter.setInsertionPoint(op); rewriter.setInsertionPoint(op);
FunctionType funcTy = func.getType(); FunctionType funcTy = func.getFunctionType();
auto resultTys = funcTy.getResults(); auto resultTys = funcTy.getResults();
bool castAdded = false; bool castAdded = false;
SmallVector<Value> castedValues; SmallVector<Value> castedValues;
for (auto it : llvm::zip(op->getOperands(), resultTys)) { for (auto it : llvm::zip(op->getOperands(), resultTys)) {
auto operand = std::get<0>(it); auto operand = std::get<0>(it);
auto currentTy = operand.getType(); auto currentTy = operand.getType();
auto castTy = std::get<1>(it); auto castTy = std::get<1>(it);
Show All 23 Lines

mlir/lib/ExecutionEngine/JitRunner.cpp

Show First 20 Lines • Show All 246 Lines • ▼ Show 20 Linesstatic Error compileAndExecuteVoidFunction(Options &options, ModuleOp module,
void *empty = nullptr; void *empty = nullptr;
return compileAndExecute(options, module, entryPoint, config, &empty); return compileAndExecute(options, module, entryPoint, config, &empty);
} }
template <typename Type> template <typename Type>
Error checkCompatibleReturnType(LLVM::LLVMFuncOp mainFunction); Error checkCompatibleReturnType(LLVM::LLVMFuncOp mainFunction);
template <> template <>
Error checkCompatibleReturnType<int32_t>(LLVM::LLVMFuncOp mainFunction) { Error checkCompatibleReturnType<int32_t>(LLVM::LLVMFuncOp mainFunction) {
auto resultType = mainFunction.getType() auto resultType = mainFunction.getFunctionType()
.cast<LLVM::LLVMFunctionType>() .cast<LLVM::LLVMFunctionType>()
.getReturnType() .getReturnType()
.dyn_cast<IntegerType>(); .dyn_cast<IntegerType>();
if (!resultType || resultType.getWidth() != 32) if (!resultType || resultType.getWidth() != 32)
return makeStringError("only single i32 function result supported"); return makeStringError("only single i32 function result supported");
return Error::success(); return Error::success();
} }
template <> template <>
Error checkCompatibleReturnType<int64_t>(LLVM::LLVMFuncOp mainFunction) { Error checkCompatibleReturnType<int64_t>(LLVM::LLVMFuncOp mainFunction) {
auto resultType = mainFunction.getType() auto resultType = mainFunction.getFunctionType()
.cast<LLVM::LLVMFunctionType>() .cast<LLVM::LLVMFunctionType>()
.getReturnType() .getReturnType()
.dyn_cast<IntegerType>(); .dyn_cast<IntegerType>();
if (!resultType || resultType.getWidth() != 64) if (!resultType || resultType.getWidth() != 64)
return makeStringError("only single i64 function result supported"); return makeStringError("only single i64 function result supported");
return Error::success(); return Error::success();
} }
template <> template <>
Error checkCompatibleReturnType<float>(LLVM::LLVMFuncOp mainFunction) { Error checkCompatibleReturnType<float>(LLVM::LLVMFuncOp mainFunction) {
if (!mainFunction.getType() if (!mainFunction.getFunctionType()
.cast<LLVM::LLVMFunctionType>() .cast<LLVM::LLVMFunctionType>()
.getReturnType() .getReturnType()
.isa<Float32Type>()) .isa<Float32Type>())
return makeStringError("only single f32 function result supported"); return makeStringError("only single f32 function result supported");
return Error::success(); return Error::success();
} }
template <typename Type> template <typename Type>
Error compileAndExecuteSingleReturnFunction(Options &options, ModuleOp module, Error compileAndExecuteSingleReturnFunction(Options &options, ModuleOp module,
StringRef entryPoint, StringRef entryPoint,
CompileAndExecuteConfig config) { CompileAndExecuteConfig config) {
auto mainFunction = module.lookupSymbol<LLVM::LLVMFuncOp>(entryPoint); auto mainFunction = module.lookupSymbol<LLVM::LLVMFuncOp>(entryPoint);
if (!mainFunction || mainFunction.isExternal()) if (!mainFunction || mainFunction.isExternal())
return makeStringError("entry point not found"); return makeStringError("entry point not found");
if (mainFunction.getType().cast<LLVM::LLVMFunctionType>().getNumParams() != 0) if (mainFunction.getFunctionType()
.cast<LLVM::LLVMFunctionType>()
.getNumParams() != 0)
return makeStringError("function inputs not supported"); return makeStringError("function inputs not supported");
if (Error error = checkCompatibleReturnType<Type>(mainFunction)) if (Error error = checkCompatibleReturnType<Type>(mainFunction))
return error; return error;
Type res; Type res;
struct { struct {
void *data; void *data;
▲ Show 20 Lines • Show All 105 Lines • Show Last 20 Lines

mlir/lib/Target/Cpp/TranslateToCpp.cpp

Show First 20 Lines • Show All 579 Lines • ▼ Show 20 Lines if (!emitter.shouldDeclareVariablesAtTop() &&
functionOp.getBlocks().size() > 1) { functionOp.getBlocks().size() > 1) {
return functionOp.emitOpError( return functionOp.emitOpError(
"with multiple blocks needs variables declared at top"); "with multiple blocks needs variables declared at top");
} }
CppEmitter::Scope scope(emitter); CppEmitter::Scope scope(emitter);
raw_indented_ostream &os = emitter.ostream(); raw_indented_ostream &os = emitter.ostream();
if (failed(emitter.emitTypes(functionOp.getLoc(), if (failed(emitter.emitTypes(functionOp.getLoc(),
functionOp.getType().getResults()))) functionOp.getFunctionType().getResults())))
return failure(); return failure();
os << " " << functionOp.getName(); os << " " << functionOp.getName();
os << "("; os << "(";
if (failed(interleaveCommaWithError( if (failed(interleaveCommaWithError(
functionOp.getArguments(), os, functionOp.getArguments(), os,
[&](BlockArgument arg) -> LogicalResult { [&](BlockArgument arg) -> LogicalResult {
if (failed(emitter.emitType(functionOp.getLoc(), arg.getType()))) if (failed(emitter.emitType(functionOp.getLoc(), arg.getType())))
▲ Show 20 Lines • Show All 431 Lines • Show Last 20 Lines

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

Show First 20 Lines • Show All 906 Lines • ▼ Show 20 Lines
} }
LogicalResult ModuleTranslation::convertFunctionSignatures() { LogicalResult ModuleTranslation::convertFunctionSignatures() {
// Declare all functions first because there may be function calls that form a // Declare all functions first because there may be function calls that form a
// call graph with cycles, or global initializers that reference functions. // call graph with cycles, or global initializers that reference functions.
for (auto function : getModuleBody(mlirModule).getOps<LLVMFuncOp>()) { for (auto function : getModuleBody(mlirModule).getOps<LLVMFuncOp>()) {
llvm::FunctionCallee llvmFuncCst = llvmModule->getOrInsertFunction( llvm::FunctionCallee llvmFuncCst = llvmModule->getOrInsertFunction(
function.getName(), function.getName(),
cast<llvm::FunctionType>(convertType(function.getType()))); cast<llvm::FunctionType>(convertType(function.getFunctionType())));
llvm::Function *llvmFunc = cast<llvm::Function>(llvmFuncCst.getCallee()); llvm::Function *llvmFunc = cast<llvm::Function>(llvmFuncCst.getCallee());
llvmFunc->setLinkage(convertLinkageToLLVM(function.getLinkage())); llvmFunc->setLinkage(convertLinkageToLLVM(function.getLinkage()));
mapFunction(function.getName(), llvmFunc); mapFunction(function.getName(), llvmFunc);
addRuntimePreemptionSpecifier(function.getDsoLocal(), llvmFunc); addRuntimePreemptionSpecifier(function.getDsoLocal(), llvmFunc);
// Forward the pass-through attributes to LLVM. // Forward the pass-through attributes to LLVM.
if (failed(forwardPassthroughAttributes( if (failed(forwardPassthroughAttributes(
function.getLoc(), function.getPassthrough(), llvmFunc))) function.getLoc(), function.getPassthrough(), llvmFunc)))
▲ Show 20 Lines • Show All 238 Lines • Show Last 20 Lines

mlir/lib/Target/SPIRV/Serialization/SerializeOps.cpp

Show First 20 Lines • Show All 174 Lines • ▼ Show 20 Lines
} }
LogicalResult Serializer::processFuncOp(spirv::FuncOp op) { LogicalResult Serializer::processFuncOp(spirv::FuncOp op) {
LLVM_DEBUG(llvm::dbgs() << "-- start function '" << op.getName() << "' --\n"); LLVM_DEBUG(llvm::dbgs() << "-- start function '" << op.getName() << "' --\n");
assert(functionHeader.empty() && functionBody.empty()); assert(functionHeader.empty() && functionBody.empty());
uint32_t fnTypeID = 0; uint32_t fnTypeID = 0;
// Generate type of the function. // Generate type of the function.
if (failed(processType(op.getLoc(), op.getType(), fnTypeID))) if (failed(processType(op.getLoc(), op.getFunctionType(), fnTypeID)))
return failure(); return failure();
// Add the function definition. // Add the function definition.
SmallVector<uint32_t, 4> operands; SmallVector<uint32_t, 4> operands;
uint32_t resTypeID = 0; uint32_t resTypeID = 0;
auto resultTypes = op.getType().getResults(); auto resultTypes = op.getFunctionType().getResults();
if (resultTypes.size() > 1) { if (resultTypes.size() > 1) {
return op.emitError("cannot serialize function with multiple return types"); return op.emitError("cannot serialize function with multiple return types");
} }
if (failed(processType(op.getLoc(), if (failed(processType(op.getLoc(),
(resultTypes.empty() ? getVoidType() : resultTypes[0]), (resultTypes.empty() ? getVoidType() : resultTypes[0]),
resTypeID))) { resTypeID))) {
return failure(); return failure();
} }
▲ Show 20 Lines • Show All 519 Lines • Show Last 20 Lines

mlir/lib/Transforms/Utils/DialectConversion.cpp

Show First 20 Lines • Show All 3,068 Lines • ▼ Show 20 Lines FunctionOpInterfaceSignatureConversion(StringRef functionLikeOpName,
MLIRContext *ctx, MLIRContext *ctx,
TypeConverter &converter) TypeConverter &converter)
: ConversionPattern(converter, functionLikeOpName, /*benefit=*/1, ctx) {} : ConversionPattern(converter, functionLikeOpName, /*benefit=*/1, ctx) {}
LogicalResult LogicalResult
matchAndRewrite(Operation *op, ArrayRef<Value> operands, matchAndRewrite(Operation *op, ArrayRef<Value> operands,
ConversionPatternRewriter &rewriter) const override { ConversionPatternRewriter &rewriter) const override {
FunctionOpInterface funcOp = cast<FunctionOpInterface>(op); FunctionOpInterface funcOp = cast<FunctionOpInterface>(op);
FunctionType type = funcOp.getType().cast<FunctionType>(); FunctionType type = funcOp.getFunctionType().cast<FunctionType>();
// Convert the original function types. // Convert the original function types.
TypeConverter::SignatureConversion result(type.getNumInputs()); TypeConverter::SignatureConversion result(type.getNumInputs());
SmallVector<Type, 1> newResults; SmallVector<Type, 1> newResults;
if (failed(typeConverter->convertSignatureArgs(type.getInputs(), result)) || if (failed(typeConverter->convertSignatureArgs(type.getInputs(), result)) ||
failed(typeConverter->convertTypes(type.getResults(), newResults)) || failed(typeConverter->convertTypes(type.getResults(), newResults)) ||
failed(rewriter.convertRegionTypes(&funcOp.getBody(), *typeConverter, failed(rewriter.convertRegionTypes(&funcOp.getBody(), *typeConverter,
&result))) &result)))
▲ Show 20 Lines • Show All 230 Lines • Show Last 20 Lines

mlir/python/mlir/dialects/_func_ops_ext.py

Show First 20 Lines • Show All 68 Lines • ▼ Show 20 Lines def is_external(self):
return len(self.regions[0].blocks) == 0 return len(self.regions[0].blocks) == 0
@property @property
def body(self): def body(self):
return self.regions[0] return self.regions[0]
@property @property
def type(self): def type(self):
return FunctionType(TypeAttr(self.attributes["type"]).value) return FunctionType(TypeAttr(self.attributes["function_type"]).value)
@property @property
def visibility(self): def visibility(self):
return self.attributes["sym_visibility"] return self.attributes["sym_visibility"]
@property @property
def name(self) -> StringAttr: def name(self) -> StringAttr:
return StringAttr(self.attributes["sym_name"]) return StringAttr(self.attributes["sym_name"])
▲ Show 20 Lines • Show All 120 Lines • ▼ Show 20 Lines def decorator(f):
# Returning a single operation is fine, coerce its results a list. # Returning a single operation is fine, coerce its results a list.
return_values = return_values.results return_values = return_values.results
else: else:
return_values = list(return_values) return_values = list(return_values)
func.ReturnOp(return_values) func.ReturnOp(return_values)
# Recompute the function type. # Recompute the function type.
return_types = [v.type for v in return_values] return_types = [v.type for v in return_values]
function_type = FunctionType.get(inputs=inputs, results=return_types) function_type = FunctionType.get(inputs=inputs, results=return_types)
func_op.attributes["type"] = TypeAttr.get(function_type) func_op.attributes["function_type"] = TypeAttr.get(function_type)
def emit_call_op(*call_args): def emit_call_op(*call_args):
call_op = func.CallOp(return_types, FlatSymbolRefAttr.get(symbol_name), call_op = func.CallOp(return_types, FlatSymbolRefAttr.get(symbol_name),
call_args) call_args)
if return_types is None: if return_types is None:
return None return None
elif len(return_types) == 1: elif len(return_types) == 1:
return call_op.result return call_op.result
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

mlir/test/CAPI/ir.c

Show First 20 Lines • Show All 89 Lines • ▼ Show 20 LinesMlirModule makeAndDumpAdd(MlirContext ctx, MlirLocation location) {
MlirAttribute funcTypeAttr = mlirAttributeParseGet( MlirAttribute funcTypeAttr = mlirAttributeParseGet(
ctx, ctx,
mlirStringRefCreateFromCString("(memref<?xf32>, memref<?xf32>) -> ()")); mlirStringRefCreateFromCString("(memref<?xf32>, memref<?xf32>) -> ()"));
MlirAttribute funcNameAttr = MlirAttribute funcNameAttr =
mlirAttributeParseGet(ctx, mlirStringRefCreateFromCString("\"add\"")); mlirAttributeParseGet(ctx, mlirStringRefCreateFromCString("\"add\""));
MlirNamedAttribute funcAttrs[] = { MlirNamedAttribute funcAttrs[] = {
mlirNamedAttributeGet( mlirNamedAttributeGet(
mlirIdentifierGet(ctx, mlirStringRefCreateFromCString("type")), mlirIdentifierGet(ctx,
mlirStringRefCreateFromCString("function_type")),
funcTypeAttr), funcTypeAttr),
mlirNamedAttributeGet( mlirNamedAttributeGet(
mlirIdentifierGet(ctx, mlirStringRefCreateFromCString("sym_name")), mlirIdentifierGet(ctx, mlirStringRefCreateFromCString("sym_name")),
funcNameAttr)}; funcNameAttr)};
MlirOperationState funcState = mlirOperationStateGet( MlirOperationState funcState = mlirOperationStateGet(
mlirStringRefCreateFromCString("func.func"), location); mlirStringRefCreateFromCString("func.func"), location);
mlirOperationStateAddAttributes(&funcState, 2, funcAttrs); mlirOperationStateAddAttributes(&funcState, 2, funcAttrs);
mlirOperationStateAddOwnedRegions(&funcState, 1, &funcBodyRegion); mlirOperationStateAddOwnedRegions(&funcState, 1, &funcBodyRegion);
▲ Show 20 Lines • Show All 1,932 Lines • Show Last 20 Lines

mlir/test/Dialect/GPU/invalid.mlir

Show First 20 Lines • Show All 325 Lines • ▼ Show 20 Lines gpu.module @gpu_funcs {
} }
} }
} }
// ----- // -----
module { module {
gpu.module @gpu_funcs { gpu.module @gpu_funcs {
// expected-error @+1 {{requires 'type' attribute of function type}} // expected-error @+1 {{attribute 'function_type' failed to satisfy constraint: type attribute of function type}}
"gpu.func"() ({ "gpu.func"() ({
gpu.return gpu.return
}) {sym_name="kernel_1", type=f32} : () -> () }) {sym_name="kernel_1", function_type=f32} : () -> ()
} }
} }
// ----- // -----
module { module {
gpu.module @gpu_funcs { gpu.module @gpu_funcs {
// expected-error @+1 {{expected memref type in attribution}} // expected-error @+1 {{expected memref type in attribution}}
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Lines
// ----- // -----
module { module {
gpu.module @gpu_funcs { gpu.module @gpu_funcs {
// expected-error @+1 {{'gpu.func' op expected at least 5 arguments to body region}} // expected-error @+1 {{'gpu.func' op expected at least 5 arguments to body region}}
"gpu.func"() ({ "gpu.func"() ({
^bb0(%arg0: f32, %arg1: memref<?xf32>, %arg2: memref<5xf32, 3>, %arg3: memref<5xf32, 5>): ^bb0(%arg0: f32, %arg1: memref<?xf32>, %arg2: memref<5xf32, 3>, %arg3: memref<5xf32, 5>):
"gpu.return"() : () -> () "gpu.return"() : () -> ()
} ) {gpu.kernel, sym_name = "kernel_1", type = (f32, memref<?xf32>) -> (), workgroup_attributions = 3: i64} : () -> () } ) {function_type = (f32, memref<?xf32>) -> (), gpu.kernel, sym_name = "kernel_1", workgroup_attributions = 3: i64} : () -> ()
} }
} }
// ----- // -----
func @sync_wait_with_result() { func @sync_wait_with_result() {
// expected-error @+1 {{cannot name an operation with no results}} // expected-error @+1 {{cannot name an operation with no results}}
%t = gpu.wait %t = gpu.wait
▲ Show 20 Lines • Show All 227 Lines • Show Last 20 Lines

mlir/test/Dialect/GPU/ops.mlir

Show First 20 Lines • Show All 156 Lines • ▼ Show 20 Lines gpu.module @gpu_funcs {
} }
} }
gpu.module @explicit_attributions { gpu.module @explicit_attributions {
// CHECK-LABEL: gpu.func @kernel_1({{.*}}: f32, {{.*}}: memref<?xf32>) workgroup({{.*}}: memref<5xf32, 3>) private({{.*}}: memref<5xf32, 5>) // CHECK-LABEL: gpu.func @kernel_1({{.*}}: f32, {{.*}}: memref<?xf32>) workgroup({{.*}}: memref<5xf32, 3>) private({{.*}}: memref<5xf32, 5>)
"gpu.func"() ({ "gpu.func"() ({
^bb0(%arg0: f32, %arg1: memref<?xf32>, %arg2: memref<5xf32, 3>, %arg3: memref<5xf32, 5>): ^bb0(%arg0: f32, %arg1: memref<?xf32>, %arg2: memref<5xf32, 3>, %arg3: memref<5xf32, 5>):
"gpu.return"() : () -> () "gpu.return"() : () -> ()
} ) {gpu.kernel, sym_name = "kernel_1", type = (f32, memref<?xf32>) -> (), workgroup_attributions = 1: i64} : () -> () } ) {function_type = (f32, memref<?xf32>) -> (), gpu.kernel, sym_name = "kernel_1", workgroup_attributions = 1: i64} : () -> ()
} }
func @alloc() { func @alloc() {
// CHECK-LABEL: func @alloc() // CHECK-LABEL: func @alloc()
// CHECK: %[[m0:.*]] = gpu.alloc () : memref<13xf32, 1> // CHECK: %[[m0:.*]] = gpu.alloc () : memref<13xf32, 1>
%m0 = gpu.alloc () : memref<13xf32, 1> %m0 = gpu.alloc () : memref<13xf32, 1>
// CHECK: gpu.dealloc %[[m0]] : memref<13xf32, 1> // CHECK: gpu.dealloc %[[m0]] : memref<13xf32, 1>
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

mlir/test/Dialect/LLVMIR/func.mlir

// RUN: mlir-opt -split-input-file -verify-diagnostics %s | mlir-opt | FileCheck %s // RUN: mlir-opt -split-input-file -verify-diagnostics %s | mlir-opt | FileCheck %s
// RUN: mlir-opt -split-input-file -verify-diagnostics -mlir-print-op-generic %s | FileCheck %s --check-prefix=GENERIC // RUN: mlir-opt -split-input-file -verify-diagnostics -mlir-print-op-generic %s | FileCheck %s --check-prefix=GENERIC
module { module {
// GENERIC: "llvm.func" // GENERIC: "llvm.func"
// GENERIC: sym_name = "foo" // GENERIC: function_type = !llvm.func<void ()>
// GENERIC-SAME: type = !llvm.func<void ()> // GENERIC-SAME: sym_name = "foo"
// GENERIC-SAME: () -> () // GENERIC-SAME: () -> ()
// CHECK: llvm.func @foo() // CHECK: llvm.func @foo()
"llvm.func"() ({ "llvm.func"() ({
}) {sym_name = "foo", type = !llvm.func<void ()>} : () -> () }) {sym_name = "foo", function_type = !llvm.func<void ()>} : () -> ()
// GENERIC: "llvm.func" // GENERIC: "llvm.func"
// GENERIC: sym_name = "bar" // GENERIC: function_type = !llvm.func<i64 (i64, i64)>
// GENERIC-SAME: type = !llvm.func<i64 (i64, i64)> // GENERIC-SAME: sym_name = "bar"
// GENERIC-SAME: () -> () // GENERIC-SAME: () -> ()
// CHECK: llvm.func @bar(i64, i64) -> i64 // CHECK: llvm.func @bar(i64, i64) -> i64
"llvm.func"() ({ "llvm.func"() ({
}) {sym_name = "bar", type = !llvm.func<i64 (i64, i64)>} : () -> () }) {sym_name = "bar", function_type = !llvm.func<i64 (i64, i64)>} : () -> ()
// GENERIC: "llvm.func" // GENERIC: "llvm.func"
// CHECK: llvm.func @baz(%{{.*}}: i64) -> i64 // CHECK: llvm.func @baz(%{{.*}}: i64) -> i64
"llvm.func"() ({ "llvm.func"() ({
// GENERIC: ^bb0 // GENERIC: ^bb0
^bb0(%arg0: i64): ^bb0(%arg0: i64):
// GENERIC: llvm.return // GENERIC: llvm.return
llvm.return %arg0 : i64 llvm.return %arg0 : i64
// GENERIC: sym_name = "baz" // GENERIC: function_type = !llvm.func<i64 (i64)>
// GENERIC-SAME: type = !llvm.func<i64 (i64)> // GENERIC-SAME: sym_name = "baz"
// GENERIC-SAME: () -> () // GENERIC-SAME: () -> ()
}) {sym_name = "baz", type = !llvm.func<i64 (i64)>} : () -> () }) {sym_name = "baz", function_type = !llvm.func<i64 (i64)>} : () -> ()
// CHECK: llvm.func @qux(!llvm.ptr<i64> {llvm.noalias}, i64) // CHECK: llvm.func @qux(!llvm.ptr<i64> {llvm.noalias}, i64)
// CHECK: attributes {xxx = {yyy = 42 : i64}} // CHECK: attributes {xxx = {yyy = 42 : i64}}
"llvm.func"() ({ "llvm.func"() ({
}) {sym_name = "qux", type = !llvm.func<void (ptr<i64>, i64)>, }) {sym_name = "qux", function_type = !llvm.func<void (ptr<i64>, i64)>,
arg_attrs = [{llvm.noalias}, {}], xxx = {yyy = 42}} : () -> () arg_attrs = [{llvm.noalias}, {}], xxx = {yyy = 42}} : () -> ()
// CHECK: llvm.func @roundtrip1() // CHECK: llvm.func @roundtrip1()
llvm.func @roundtrip1() llvm.func @roundtrip1()
// CHECK: llvm.func @roundtrip2(i64, f32) -> f64 // CHECK: llvm.func @roundtrip2(i64, f32) -> f64
llvm.func @roundtrip2(i64, f32) -> f64 llvm.func @roundtrip2(i64, f32) -> f64
▲ Show 20 Lines • Show All 92 Lines • ▼ Show 20 Lines llvm.func @res_struct_attr(%arg0 : !llvm.struct<(i32)>)
llvm.return %arg0 : !llvm.struct<(i32)> llvm.return %arg0 : !llvm.struct<(i32)>
} }
} }
// ----- // -----
module { module {
// expected-error@+1 {{requires one region}} // expected-error@+1 {{requires one region}}
"llvm.func"() {sym_name = "no_region", type = !llvm.func<void ()>} : () -> () "llvm.func"() {function_type = !llvm.func<void ()>, sym_name = "no_region"} : () -> ()
} }
// ----- // -----
module { module {
// expected-error@+1 {{requires a type attribute 'type'}} // expected-error@+1 {{requires attribute 'function_type'}}
"llvm.func"() ({}) {sym_name = "missing_type"} : () -> () "llvm.func"() ({}) {sym_name = "missing_type"} : () -> ()
} }
// ----- // -----
module { module {
// expected-error@+1 {{requires 'type' attribute of wrapped LLVM function type}} // expected-error@+1 {{attribute 'function_type' failed to satisfy constraint: type attribute of LLVM function type}}
"llvm.func"() ({}) {sym_name = "non_llvm_type", type = i64} : () -> () "llvm.func"() ({}) {sym_name = "non_llvm_type", function_type = i64} : () -> ()
} }
// ----- // -----
module { module {
// expected-error@+1 {{requires 'type' attribute of wrapped LLVM function type}} // expected-error@+1 {{attribute 'function_type' failed to satisfy constraint: type attribute of LLVM function type}}
"llvm.func"() ({}) {sym_name = "non_function_type", type = i64} : () -> () "llvm.func"() ({}) {sym_name = "non_function_type", function_type = i64} : () -> ()
} }
// ----- // -----
module { module {
// expected-error@+1 {{entry block must have 0 arguments}} // expected-error@+1 {{entry block must have 0 arguments}}
"llvm.func"() ({ "llvm.func"() ({
^bb0(%arg0: i64): ^bb0(%arg0: i64):
llvm.return llvm.return
}) {sym_name = "wrong_arg_number", type = !llvm.func<void ()>} : () -> () }) {function_type = !llvm.func<void ()>, sym_name = "wrong_arg_number"} : () -> ()
} }
// ----- // -----
module { module {
// expected-error@+1 {{entry block argument #0('tensor<*xf32>') must match the type of the corresponding argument in function signature('i64')}} // expected-error@+1 {{entry block argument #0('tensor<*xf32>') must match the type of the corresponding argument in function signature('i64')}}
"llvm.func"() ({ "llvm.func"() ({
^bb0(%arg0: tensor<*xf32>): ^bb0(%arg0: tensor<*xf32>):
llvm.return llvm.return
}) {sym_name = "wrong_arg_number", type = !llvm.func<void (i64)>} : () -> () }) {function_type = !llvm.func<void (i64)>, sym_name = "wrong_arg_number"} : () -> ()
} }
// ----- // -----
module { module {
// expected-error@+1 {{failed to construct function type: expected LLVM type for function arguments}} // expected-error@+1 {{failed to construct function type: expected LLVM type for function arguments}}
llvm.func @foo(tensor<*xf32>) llvm.func @foo(tensor<*xf32>)
} }
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

mlir/test/IR/invalid-func-op.mlir

Show First 20 Lines • Show All 85 Lines • ▼ Show 20 Lines
// ----- // -----
// expected-error@+1 {{'sym_name' is an inferred attribute and should not be specified in the explicit attribute dictionary}} // expected-error@+1 {{'sym_name' is an inferred attribute and should not be specified in the explicit attribute dictionary}}
func private @invalid_symbol_name_attr() attributes { sym_name = "x" } func private @invalid_symbol_name_attr() attributes { sym_name = "x" }
// ----- // -----
// expected-error@+1 {{'type' is an inferred attribute and should not be specified in the explicit attribute dictionary}} // expected-error@+1 {{'function_type' is an inferred attribute and should not be specified in the explicit attribute dictionary}}
func private @invalid_symbol_type_attr() attributes { type = "x" } func private @invalid_symbol_type_attr() attributes { function_type = "x" }
// ----- // -----
// expected-error@+1 {{argument attribute array `arg_attrs` to have the same number of elements as the number of function arguments}} // expected-error@+1 {{argument attribute array `arg_attrs` to have the same number of elements as the number of function arguments}}
func private @invalid_arg_attrs() attributes { arg_attrs = [{}] } func private @invalid_arg_attrs() attributes { arg_attrs = [{}] }
// ----- // -----
Show All 12 Lines

mlir/test/IR/parser.mlir

Show First 20 Lines • Show All 1,410 Lines • ▼ Show 20 Lines
// CHECK: "unregistered_func_might_have_graph_region"() ({ // CHECK: "unregistered_func_might_have_graph_region"() ({
// CHECK: [[VAL1:%.*]] = "foo"([[VAL1]], [[VAL2:%.*]]) : (i64, i64) -> i64 // CHECK: [[VAL1:%.*]] = "foo"([[VAL1]], [[VAL2:%.*]]) : (i64, i64) -> i64
// CHECK: [[VAL2]] = "bar"([[VAL1]]) // CHECK: [[VAL2]] = "bar"([[VAL1]])
"unregistered_func_might_have_graph_region"() ({ "unregistered_func_might_have_graph_region"() ({
%1 = "foo"(%1, %2) : (i64, i64) -> i64 %1 = "foo"(%1, %2) : (i64, i64) -> i64
%2 = "bar"(%1) : (i64) -> i64 %2 = "bar"(%1) : (i64) -> i64
"unregistered_terminator"() : () -> () "unregistered_terminator"() : () -> ()
}) {sym_name = "unregistered_op_dominance_violation_ok", type = () -> i1} : () -> () }) {sym_name = "unregistered_op_dominance_violation_ok", function_type = () -> i1} : () -> ()
// This is an unregister operation, the printing/parsing is handled by the dialect. // This is an unregister operation, the printing/parsing is handled by the dialect.
// CHECK: test.dialect_custom_printer custom_format // CHECK: test.dialect_custom_printer custom_format
test.dialect_custom_printer custom_format test.dialect_custom_printer custom_format
// This is a registered operation with no custom parser and printer, and should // This is a registered operation with no custom parser and printer, and should
// be handled by the dialect. // be handled by the dialect.
// CHECK: test.dialect_custom_format_fallback custom_format_fallback // CHECK: test.dialect_custom_format_fallback custom_format_fallback
test.dialect_custom_format_fallback custom_format_fallback test.dialect_custom_format_fallback custom_format_fallback
// Check that an op with an optional result parses f80 as type. // Check that an op with an optional result parses f80 as type.
// CHECK: test.format_optional_result_d_op : f80 // CHECK: test.format_optional_result_d_op : f80
test.format_optional_result_d_op : f80 test.format_optional_result_d_op : f80

mlir/test/lib/Dialect/Func/TestDecomposeCallGraphTypes.cpp

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines void runOnOperation() override {
target.addLegalDialect<test::TestDialect>(); target.addLegalDialect<test::TestDialect>();
target.addDynamicallyLegalOp<func::ReturnOp>([&](func::ReturnOp op) { target.addDynamicallyLegalOp<func::ReturnOp>([&](func::ReturnOp op) {
return typeConverter.isLegal(op.getOperandTypes()); return typeConverter.isLegal(op.getOperandTypes());
}); });
target.addDynamicallyLegalOp<func::CallOp>( target.addDynamicallyLegalOp<func::CallOp>(
[&](func::CallOp op) { return typeConverter.isLegal(op); }); [&](func::CallOp op) { return typeConverter.isLegal(op); });
target.addDynamicallyLegalOp<FuncOp>([&](FuncOp op) { target.addDynamicallyLegalOp<FuncOp>([&](FuncOp op) {
return typeConverter.isSignatureLegal(op.getType()); return typeConverter.isSignatureLegal(op.getFunctionType());
}); });
typeConverter.addConversion([](Type type) { return type; }); typeConverter.addConversion([](Type type) { return type; });
typeConverter.addConversion( typeConverter.addConversion(
[](TupleType tupleType, SmallVectorImpl<Type> &types) { [](TupleType tupleType, SmallVectorImpl<Type> &types) {
tupleType.getFlattenedTypes(types); tupleType.getFlattenedTypes(types);
return success(); return success();
}); });
Show All 39 Lines

mlir/test/lib/Dialect/Test/TestPatterns.cpp

Show First 20 Lines • Show All 670 Lines • ▼ Show 20 Lines void runOnOperation() override {
target target
.addIllegalOp<ILLegalOpF, TestRegionBuilderOp, TestOpWithRegionFold>(); .addIllegalOp<ILLegalOpF, TestRegionBuilderOp, TestOpWithRegionFold>();
target.addDynamicallyLegalOp<TestReturnOp>([](TestReturnOp op) { target.addDynamicallyLegalOp<TestReturnOp>([](TestReturnOp op) {
// Don't allow F32 operands. // Don't allow F32 operands.
return llvm::none_of(op.getOperandTypes(), return llvm::none_of(op.getOperandTypes(),
[](Type type) { return type.isF32(); }); [](Type type) { return type.isF32(); });
}); });
target.addDynamicallyLegalOp<FuncOp>([&](FuncOp op) { target.addDynamicallyLegalOp<FuncOp>([&](FuncOp op) {
return converter.isSignatureLegal(op.getType()) && return converter.isSignatureLegal(op.getFunctionType()) &&
converter.isLegal(&op.getBody()); converter.isLegal(&op.getBody());
}); });
target.addDynamicallyLegalOp<func::CallOp>( target.addDynamicallyLegalOp<func::CallOp>(
[&](func::CallOp op) { return converter.isLegal(op); }); [&](func::CallOp op) { return converter.isLegal(op); });
// TestCreateUnregisteredOp creates `arith.constant` operation, // TestCreateUnregisteredOp creates `arith.constant` operation,
// which was not added to target intentionally to test // which was not added to target intentionally to test
// correct error code from conversion driver. // correct error code from conversion driver.
▲ Show 20 Lines • Show All 413 Lines • ▼ Show 20 Lines void runOnOperation() override {
mlir::ConversionTarget target(getContext()); mlir::ConversionTarget target(getContext());
target.addDynamicallyLegalOp<TestTypeProducerOp>([](TestTypeProducerOp op) { target.addDynamicallyLegalOp<TestTypeProducerOp>([](TestTypeProducerOp op) {
auto recursiveType = op.getType().dyn_cast<test::TestRecursiveType>(); auto recursiveType = op.getType().dyn_cast<test::TestRecursiveType>();
return op.getType().isF64() || op.getType().isInteger(64) || return op.getType().isF64() || op.getType().isInteger(64) ||
(recursiveType && (recursiveType &&
recursiveType.getName() == "outer_converted_type"); recursiveType.getName() == "outer_converted_type");
}); });
target.addDynamicallyLegalOp<FuncOp>([&](FuncOp op) { target.addDynamicallyLegalOp<FuncOp>([&](FuncOp op) {
return converter.isSignatureLegal(op.getType()) && return converter.isSignatureLegal(op.getFunctionType()) &&
converter.isLegal(&op.getBody()); converter.isLegal(&op.getBody());
}); });
target.addDynamicallyLegalOp<TestCastOp>([&](TestCastOp op) { target.addDynamicallyLegalOp<TestCastOp>([&](TestCastOp op) {
// Allow casts from F64 to F32. // Allow casts from F64 to F32.
return (*op.operand_type_begin()).isF64() && op.getType().isF32(); return (*op.operand_type_begin()).isF64() && op.getType().isF32();
}); });
target.addDynamicallyLegalOp<TestSignatureConversionNoConverterOp>( target.addDynamicallyLegalOp<TestSignatureConversionNoConverterOp>(
[&](TestSignatureConversionNoConverterOp op) { [&](TestSignatureConversionNoConverterOp op) {
▲ Show 20 Lines • Show All 261 Lines • Show Last 20 Lines

mlir/test/lib/IR/TestFunc.cpp

Show First 20 Lines • Show All 128 Lines • ▼ Show 20 Linesstruct TestFuncSetType
void runOnOperation() override { void runOnOperation() override {
auto module = getOperation(); auto module = getOperation();
SymbolTable symbolTable(module); SymbolTable symbolTable(module);
for (auto func : module.getOps<FunctionOpInterface>()) { for (auto func : module.getOps<FunctionOpInterface>()) {
auto sym = func->getAttrOfType<FlatSymbolRefAttr>("test.set_type_from"); auto sym = func->getAttrOfType<FlatSymbolRefAttr>("test.set_type_from");
if (!sym) if (!sym)
continue; continue;
func.setType( func.setType(symbolTable.lookup<FunctionOpInterface>(sym.getValue())
symbolTable.lookup<FunctionOpInterface>(sym.getValue()).getType()); .getFunctionType());
} }
} }
}; };
} // namespace } // namespace
namespace mlir { namespace mlir {
void registerTestFunc() { void registerTestFunc() {
PassRegistration<TestFuncInsertArg>(); PassRegistration<TestFuncInsertArg>();
Show All 10 Lines

mlir/test/lib/IR/TestSlicing.cpp

Show All 23 Lines
/// Create a function with the same signature as the parent function of `op` /// Create a function with the same signature as the parent function of `op`
/// with name being the function name and a `suffix`. /// with name being the function name and a `suffix`.
static LogicalResult createBackwardSliceFunction(Operation *op, static LogicalResult createBackwardSliceFunction(Operation *op,
StringRef suffix) { StringRef suffix) {
FuncOp parentFuncOp = op->getParentOfType<FuncOp>(); FuncOp parentFuncOp = op->getParentOfType<FuncOp>();
OpBuilder builder(parentFuncOp); OpBuilder builder(parentFuncOp);
Location loc = op->getLoc(); Location loc = op->getLoc();
std::string clonedFuncOpName = parentFuncOp.getName().str() + suffix.str(); std::string clonedFuncOpName = parentFuncOp.getName().str() + suffix.str();
FuncOp clonedFuncOp = FuncOp clonedFuncOp = builder.create<FuncOp>(loc, clonedFuncOpName,
builder.create<FuncOp>(loc, clonedFuncOpName, parentFuncOp.getType()); parentFuncOp.getFunctionType());
BlockAndValueMapping mapper; BlockAndValueMapping mapper;
builder.setInsertionPointToEnd(clonedFuncOp.addEntryBlock()); builder.setInsertionPointToEnd(clonedFuncOp.addEntryBlock());
for (const auto &arg : enumerate(parentFuncOp.getArguments())) for (const auto &arg : enumerate(parentFuncOp.getArguments()))
mapper.map(arg.value(), clonedFuncOp.getArgument(arg.index())); mapper.map(arg.value(), clonedFuncOp.getArgument(arg.index()));
SetVector<Operation *> slice; SetVector<Operation *> slice;
getBackwardSlice(op, &slice); getBackwardSlice(op, &slice);
for (Operation *slicedOp : slice) for (Operation *slicedOp : slice)
builder.clone(*slicedOp, mapper); builder.clone(*slicedOp, mapper);
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

mlir/test/mlir-lsp-server/hover.test

Show First 20 Lines • Show All 108 Lines • ▼ Show 20 Lines// Hover on a region operation.
"textDocument":{"uri":"test:///foo.mlir"}, "textDocument":{"uri":"test:///foo.mlir"},
"position":{"line":0,"character":1} "position":{"line":0,"character":1}
}} }}
// CHECK: "id": 5, // CHECK: "id": 5,
// CHECK-NEXT: "jsonrpc": "2.0", // CHECK-NEXT: "jsonrpc": "2.0",
// CHECK-NEXT: "result": { // CHECK-NEXT: "result": {
// CHECK-NEXT: "contents": { // CHECK-NEXT: "contents": {
// CHECK-NEXT: "kind": "markdown", // CHECK-NEXT: "kind": "markdown",
// CHECK-NEXT: "value": "\"func.func\" : public @foo\n\nGeneric Form:\n\n```mlir\n\"func.func\"() ({\n}) {sym_name = \"foo\", type = (i1) -> ()} : () -> ()\n```\n" // CHECK-NEXT: "value": "\"func.func\" : public @foo\n\nGeneric Form:\n\n```mlir\n\"func.func\"() ({\n}) {function_type = (i1) -> (), sym_name = \"foo\"} : () -> ()\n```\n"
// CHECK-NEXT: }, // CHECK-NEXT: },
// CHECK-NEXT: "range": { // CHECK-NEXT: "range": {
// CHECK-NEXT: "end": { // CHECK-NEXT: "end": {
// CHECK-NEXT: "character": 4, // CHECK-NEXT: "character": 4,
// CHECK-NEXT: "line": 0 // CHECK-NEXT: "line": 0
// CHECK-NEXT: }, // CHECK-NEXT: },
// CHECK-NEXT: "start": { // CHECK-NEXT: "start": {
// CHECK-NEXT: "character": 0, // CHECK-NEXT: "character": 0,
// CHECK-NEXT: "line": 0 // CHECK-NEXT: "line": 0
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// ----- // -----
// Hover on a symbol reference. // Hover on a symbol reference.
{"jsonrpc":"2.0","id":6,"method":"textDocument/hover","params":{ {"jsonrpc":"2.0","id":6,"method":"textDocument/hover","params":{
"textDocument":{"uri":"test:///foo.mlir"}, "textDocument":{"uri":"test:///foo.mlir"},
"position":{"line":0,"character":8} "position":{"line":0,"character":8}
}} }}
// CHECK: "id": 6, // CHECK: "id": 6,
// CHECK-NEXT: "jsonrpc": "2.0", // CHECK-NEXT: "jsonrpc": "2.0",
// CHECK-NEXT: "result": { // CHECK-NEXT: "result": {
// CHECK-NEXT: "contents": { // CHECK-NEXT: "contents": {
// CHECK-NEXT: "kind": "markdown", // CHECK-NEXT: "kind": "markdown",
// CHECK-NEXT: "value": "\"func.func\" : public @foo\n\nGeneric Form:\n\n```mlir\n\"func.func\"() ({\n}) {sym_name = \"foo\", type = (i1) -> ()} : () -> ()\n```\n" // CHECK-NEXT: "value": "\"func.func\" : public @foo\n\nGeneric Form:\n\n```mlir\n\"func.func\"() ({\n}) {function_type = (i1) -> (), sym_name = \"foo\"} : () -> ()\n```\n"
// CHECK-NEXT: }, // CHECK-NEXT: },
// CHECK-NEXT: "range": { // CHECK-NEXT: "range": {
// CHECK-NEXT: "end": { // CHECK-NEXT: "end": {
// CHECK-NEXT: "character": 9, // CHECK-NEXT: "character": 9,
// CHECK-NEXT: "line": 0 // CHECK-NEXT: "line": 0
// CHECK-NEXT: }, // CHECK-NEXT: },
// CHECK-NEXT: "start": { // CHECK-NEXT: "start": {
// CHECK-NEXT: "character": 5, // CHECK-NEXT: "character": 5,
// CHECK-NEXT: "line": 0 // CHECK-NEXT: "line": 0
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// ----- // -----
{"jsonrpc":"2.0","id":7,"method":"shutdown"} {"jsonrpc":"2.0","id":7,"method":"shutdown"}
// ----- // -----
{"jsonrpc":"2.0","method":"exit"} {"jsonrpc":"2.0","method":"exit"}