1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
|
//===-- CharacterRuntime.cpp -- runtime for CHARACTER type entities -------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "flang/Lower/CharacterRuntime.h"
#include "../../runtime/character.h"
#include "RTBuilder.h"
#include "flang/Lower/Bridge.h"
#include "flang/Lower/CharacterExpr.h"
#include "flang/Lower/FIRBuilder.h"
#include "mlir/Dialect/StandardOps/IR/Ops.h"
using namespace Fortran::runtime;
#define NAMIFY_HELPER(X) #X
#define NAMIFY(X) NAMIFY_HELPER(IONAME(X))
#define mkRTKey(X) mkKey(RTNAME(X))
namespace Fortran::lower {
/// Static table of CHARACTER runtime calls
///
/// This logical map contains the name and type builder function for each
/// runtime function listed in the tuple. This table is fully constructed at
/// compile-time. Use the `mkRTKey` macro to access the table.
static constexpr std::tuple<
mkRTKey(CharacterCompareScalar), mkRTKey(CharacterCompareScalar1),
mkRTKey(CharacterCompareScalar2), mkRTKey(CharacterCompareScalar4),
mkRTKey(CharacterCompare)>
newCharRTTable;
} // namespace Fortran::lower
using namespace Fortran::lower;
/// Helper function to retrieve the name of the IO function given the key `A`
template <typename A>
static constexpr const char *getName() {
return std::get<A>(newCharRTTable).name;
}
/// Helper function to retrieve the type model signature builder of the IO
/// function as defined by the key `A`
template <typename A>
static constexpr FuncTypeBuilderFunc getTypeModel() {
return std::get<A>(newCharRTTable).getTypeModel();
}
inline int64_t getLength(mlir::Type argTy) {
return argTy.cast<fir::SequenceType>().getShape()[0];
}
/// Get (or generate) the MLIR FuncOp for a given runtime function.
template <typename E>
static mlir::FuncOp getRuntimeFunc(mlir::Location loc,
Fortran::lower::FirOpBuilder &builder) {
auto name = getName<E>();
auto func = builder.getNamedFunction(name);
if (func)
return func;
auto funTy = getTypeModel<E>()(builder.getContext());
func = builder.createFunction(loc, name, funTy);
func->setAttr("fir.runtime", builder.getUnitAttr());
return func;
}
/// Helper function to recover the KIND from the FIR type.
static int discoverKind(mlir::Type ty) {
if (auto charTy = ty.dyn_cast<fir::CharacterType>())
return charTy.getFKind();
if (auto eleTy = fir::dyn_cast_ptrEleTy(ty))
return discoverKind(eleTy);
if (auto arrTy = ty.dyn_cast<fir::SequenceType>())
return discoverKind(arrTy.getEleTy());
if (auto boxTy = ty.dyn_cast<fir::BoxCharType>())
return discoverKind(boxTy.getEleTy());
if (auto boxTy = ty.dyn_cast<fir::BoxType>())
return discoverKind(boxTy.getEleTy());
llvm_unreachable("unexpected character type");
}
//===----------------------------------------------------------------------===//
// Lower character operations
//===----------------------------------------------------------------------===//
mlir::Value
Fortran::lower::genRawCharCompare(Fortran::lower::AbstractConverter &converter,
mlir::Location loc, mlir::CmpIPredicate cmp,
mlir::Value lhsBuff, mlir::Value lhsLen,
mlir::Value rhsBuff, mlir::Value rhsLen) {
auto &builder = converter.getFirOpBuilder();
mlir::FuncOp beginFunc;
switch (discoverKind(lhsBuff.getType())) {
case 1:
beginFunc = getRuntimeFunc<mkRTKey(CharacterCompareScalar1)>(loc, builder);
break;
case 2:
beginFunc = getRuntimeFunc<mkRTKey(CharacterCompareScalar2)>(loc, builder);
break;
case 4:
beginFunc = getRuntimeFunc<mkRTKey(CharacterCompareScalar4)>(loc, builder);
break;
default:
llvm_unreachable("runtime does not support CHARACTER KIND");
}
auto fTy = beginFunc.getType();
auto lptr = builder.createConvert(loc, fTy.getInput(0), lhsBuff);
auto llen = builder.createConvert(loc, fTy.getInput(2), lhsLen);
auto rptr = builder.createConvert(loc, fTy.getInput(1), rhsBuff);
auto rlen = builder.createConvert(loc, fTy.getInput(3), rhsLen);
llvm::SmallVector<mlir::Value, 4> args = {lptr, rptr, llen, rlen};
auto tri = builder.create<mlir::CallOp>(loc, beginFunc, args).getResult(0);
auto zero = builder.createIntegerConstant(loc, tri.getType(), 0);
return builder.create<mlir::CmpIOp>(loc, cmp, tri, zero);
}
mlir::Value
Fortran::lower::genBoxCharCompare(Fortran::lower::AbstractConverter &converter,
mlir::Location loc, mlir::CmpIPredicate cmp,
mlir::Value lhs, mlir::Value rhs) {
auto &builder = converter.getFirOpBuilder();
Fortran::lower::CharacterExprHelper helper{builder, loc};
auto lhsPair = helper.materializeCharacter(lhs);
auto rhsPair = helper.materializeCharacter(rhs);
return genRawCharCompare(converter, loc, cmp, lhsPair.first, lhsPair.second,
rhsPair.first, rhsPair.second);
}
|
