Character.h

//===-- Character.h -- lowering of characters -------------------*- C++ -*-===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
//
//===----------------------------------------------------------------------===//
 
#ifndef FORTRAN_OPTIMIZER_BUILDER_CHARACTER_H
#define FORTRAN_OPTIMIZER_BUILDER_CHARACTER_H
 
#include "flang/Optimizer/Builder/BoxValue.h"
#include "flang/Optimizer/Builder/LowLevelIntrinsics.h"
#include "flang/Optimizer/Builder/Runtime/Character.h"
 
namespace fir {
class FirOpBuilder;
}
 
namespace fir::factory {
 
class CharacterExprHelper {
public:
  explicit CharacterExprHelper(FirOpBuilder &builder, mlir::Location loc)
      : builder{builder}, loc{loc} {}
  CharacterExprHelper(const CharacterExprHelper &) = delete;
 
  void createCopy(const fir::CharBoxValue &dest, const fir::CharBoxValue &src,
                  mlir::Value count);
 
  void createPadding(const fir::CharBoxValue &str, mlir::Value lower,
                     mlir::Value upper);
 
  fir::CharBoxValue createSubstring(const fir::CharBoxValue &str,
                                    llvm::ArrayRef<mlir::Value> bounds);
 
  mlir::Value genSubstringBase(mlir::Value stringRawAddr,
                               mlir::Value lowerBound,
                               mlir::Type substringAddrType,
                               mlir::Value one = {});
 
  mlir::Value createBlankConstant(fir::CharacterType type);
 
  void createAssign(const fir::ExtendedValue &lhs,
                    const fir::ExtendedValue &rhs);
 
  fir::CharBoxValue createConcatenate(const fir::CharBoxValue &lhs,
                                      const fir::CharBoxValue &rhs);
 
  fir::CharBoxValue
  createCharExtremum(bool predIsMin, llvm::ArrayRef<fir::CharBoxValue> opCBVs);
 
  mlir::Value createLenTrim(const fir::CharBoxValue &str);
 
  mlir::Value createEmboxChar(mlir::Value addr, mlir::Value len);
  mlir::Value createEmbox(const fir::CharBoxValue &str);
  mlir::Value createEmbox(const fir::CharArrayBoxValue &str);
 
  fir::CharBoxValue toScalarCharacter(const fir::CharArrayBoxValue &);
 
  std::pair<mlir::Value, mlir::Value> createUnboxChar(mlir::Value boxChar);
 
  fir::CharBoxValue createCharacterTemp(mlir::Type type, mlir::Value len);
 
  fir::CharBoxValue createCharacterTemp(mlir::Type type, int len);
 
  fir::CharBoxValue createTempFrom(const fir::ExtendedValue &source);
 
  static bool isCharacterLiteral(mlir::Type type);
 
  static bool isCharacterScalar(mlir::Type type);
 
  static bool hasConstantLengthInType(const fir::ExtendedValue &);
 
  static fir::KindTy getCharacterKind(mlir::Type type);
 
  static fir::KindTy getCharacterOrSequenceKind(mlir::Type type);
 
  // TODO: Do we really need all these flavors of unwrapping to get the fir.char
  // type? Or can we merge these? It would be better to merge them and eliminate
  // the confusion.
 
  static fir::CharacterType getCharType(mlir::Type type);
 
  static fir::CharacterType getCharacterType(mlir::Type type);
  static fir::CharacterType getCharacterType(const fir::CharBoxValue &box);
  static fir::CharacterType getCharacterType(mlir::Value str);
 
  fir::ExtendedValue toExtendedValue(mlir::Value character,
                                     mlir::Value len = {});
 
  static bool isArray(mlir::Type type);
 
  fir::ExtendedValue cleanUpCharacterExtendedValue(const fir::ExtendedValue &);
 
  mlir::Value createSingletonFromCode(mlir::Value code, int kind);
  mlir::Value extractCodeFromSingleton(mlir::Value singleton);
 
  mlir::Value getLength(mlir::Value memref);
 
  mlir::Value readLengthFromBox(mlir::Value box);
 
  mlir::Value readLengthFromBox(mlir::Value box, fir::CharacterType charTy);
 
private:
  fir::CharBoxValue materializeValue(mlir::Value str);
  mlir::Value getCharBoxBuffer(const fir::CharBoxValue &box);
  mlir::Value createElementAddr(mlir::Value buffer, mlir::Value index);
  mlir::Value createLoadCharAt(mlir::Value buff, mlir::Value index);
  void createStoreCharAt(mlir::Value str, mlir::Value index, mlir::Value c);
  void createLengthOneAssign(const fir::CharBoxValue &lhs,
                             const fir::CharBoxValue &rhs);
  void createAssign(const fir::CharBoxValue &lhs, const fir::CharBoxValue &rhs);
  mlir::Value createBlankConstantCode(fir::CharacterType type);
 
private:
  FirOpBuilder &builder;
  mlir::Location loc;
};
 
//===----------------------------------------------------------------------===//
// Tools to work with Character dummy procedures
//===----------------------------------------------------------------------===//
 
mlir::Type getCharacterProcedureTupleType(mlir::Type funcPointerType);
 
mlir::Value createCharacterProcedureTuple(fir::FirOpBuilder &builder,
                                          mlir::Location loc,
                                          mlir::Type tupleType,
                                          mlir::Value addr, mlir::Value len);
 
std::pair<mlir::Value, mlir::Value>
extractCharacterProcedureTuple(fir::FirOpBuilder &builder, mlir::Location loc,
                               mlir::Value tuple, bool openBoxProc = true);
 
fir::CharBoxValue convertCharacterKind(fir::FirOpBuilder &builder,
                                       mlir::Location loc,
                                       fir::CharBoxValue srcBoxChar,
                                       int toKind);
 
} // namespace fir::factory
 
#endif // FORTRAN_OPTIMIZER_BUILDER_CHARACTER_H