VectorSubscripts.h

Go to the documentation of this file.

//===-- VectorSubscripts.h -- vector subscripts tools -----------*- 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
//
//===----------------------------------------------------------------------===//
//===----------------------------------------------------------------------===//
 
#ifndef FORTRAN_LOWER_VECTORSUBSCRIPTS_H
#define FORTRAN_LOWER_VECTORSUBSCRIPTS_H
 
#include "flang/Optimizer/Builder/BoxValue.h"
 
namespace fir {
class FirOpBuilder;
}
 
namespace Fortran {
 
namespace evaluate {
template <typename>
class Expr;
struct SomeType;
} // namespace evaluate
 
namespace lower {
 
class AbstractConverter;
class StatementContext;
 
class VectorSubscriptBox {
public:
  using ElementalGenerator = std::function<void(const fir::ExtendedValue &)>;
  using ElementalGeneratorWithBoolReturn =
      std::function<mlir::Value(const fir::ExtendedValue &)>;
  struct LoweredVectorSubscript {
    LoweredVectorSubscript(fir::ExtendedValue &&vector, mlir::Value size)
        : vector{std::move(vector)}, size{size} {}
    fir::ExtendedValue vector;
    // Vector size, guaranteed to be of indexType.
    mlir::Value size;
  };
  struct LoweredTriplet {
    // Triplets value, guaranteed to be of indexType.
    mlir::Value lb;
    mlir::Value ub;
    mlir::Value stride;
  };
  using LoweredSubscript =
      std::variant<mlir::Value, LoweredTriplet, LoweredVectorSubscript>;
  using MaybeSubstring = llvm::SmallVector<mlir::Value, 2>;
  VectorSubscriptBox(
      fir::ExtendedValue &&loweredBase,
      llvm::SmallVector<LoweredSubscript, 16> &&loweredSubscripts,
      llvm::SmallVector<mlir::Value> &&componentPath,
      MaybeSubstring substringBounds, mlir::Type elementType)
      : loweredBase{std::move(loweredBase)}, loweredSubscripts{std::move(
                                                 loweredSubscripts)},
        componentPath{std::move(componentPath)},
        substringBounds{substringBounds}, elementType{elementType} {};
 
  void loopOverElements(fir::FirOpBuilder &builder, mlir::Location loc,
                        const ElementalGenerator &elementalGenerator);
 
  mlir::Value loopOverElementsWhile(
      fir::FirOpBuilder &builder, mlir::Location loc,
      const ElementalGeneratorWithBoolReturn &elementalGenerator,
      mlir::Value initialCondition);
 
  mlir::Type getElementType() { return elementType; }
 
private:
  template <typename LoopType, typename Generator>
  mlir::Value loopOverElementsBase(fir::FirOpBuilder &builder,
                                   mlir::Location loc,
                                   const Generator &elementalGenerator,
                                   mlir::Value initialCondition);
  mlir::Value createSlice(fir::FirOpBuilder &builder, mlir::Location loc);
 
  fir::ExtendedValue getElementAt(fir::FirOpBuilder &builder,
                                  mlir::Location loc, mlir::Value shape,
                                  mlir::Value slice,
                                  mlir::ValueRange inductionVariables);
 
  llvm::SmallVector<std::tuple<mlir::Value, mlir::Value, mlir::Value>>
  genLoopBounds(fir::FirOpBuilder &builder, mlir::Location loc);
 
  fir::ExtendedValue loweredBase;
  llvm::SmallVector<LoweredSubscript, 16> loweredSubscripts;
  llvm::SmallVector<mlir::Value> componentPath;
  MaybeSubstring substringBounds;
  mlir::Type elementType;
};
 
VectorSubscriptBox genVectorSubscriptBox(
    mlir::Location loc, Fortran::lower::AbstractConverter &converter,
    Fortran::lower::StatementContext &stmtCtx,
    const Fortran::evaluate::Expr<Fortran::evaluate::SomeType> &expr);
 
} // namespace lower
} // namespace Fortran
 
#endif // FORTRAN_LOWER_VECTORSUBSCRIPTS_H