InternalNames.h

//===-- Optimizer/Support/InternalNames.h -----------------------*- 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_OPTIMIZER_SUPPORT_INTERNALNAMES_H
#define FORTRAN_OPTIMIZER_SUPPORT_INTERNALNAMES_H
 
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/StringRef.h"
#include <cstdint>
 
namespace fir {
 
static constexpr llvm::StringRef kNameSeparator = ".";
static constexpr llvm::StringRef kBoundsSeparator = ".b.";
static constexpr llvm::StringRef kComponentSeparator = ".c.";
static constexpr llvm::StringRef kComponentInitSeparator = ".di.";
static constexpr llvm::StringRef kDataPtrInitSeparator = ".dp.";
static constexpr llvm::StringRef kTypeDescriptorSeparator = ".dt.";
static constexpr llvm::StringRef kKindParameterSeparator = ".kp.";
static constexpr llvm::StringRef kLenKindSeparator = ".lpk.";
static constexpr llvm::StringRef kLenParameterSeparator = ".lv.";
static constexpr llvm::StringRef kNameStringSeparator = ".n.";
static constexpr llvm::StringRef kProcPtrSeparator = ".p.";
static constexpr llvm::StringRef kSpecialBindingSeparator = ".s.";
static constexpr llvm::StringRef kBindingTableSeparator = ".v.";
static constexpr llvm::StringRef boxprocSuffix = "UnboxProc";
static constexpr llvm::StringRef kDerivedTypeInitSuffix = "DerivedInit";

struct NameUniquer {
  enum class IntrinsicType { CHARACTER, COMPLEX, INTEGER, LOGICAL, REAL };

  enum class NameKind {
    NOT_UNIQUED,
    BLOCK_DATA_NAME,
    COMMON,
    CONSTANT,
    DERIVED_TYPE,
    DISPATCH_TABLE,
    GENERATED,
    INTRINSIC_TYPE_DESC,
    NAMELIST_GROUP,
    PROCEDURE,
    TYPE_DESC,
    VARIABLE
  };

  struct DeconstructedName {
    DeconstructedName(llvm::StringRef name) : name{name} {}
    DeconstructedName(llvm::ArrayRef<std::string> modules,
                      llvm::ArrayRef<std::string> procs, std::int64_t blockId,
                      llvm::StringRef name, llvm::ArrayRef<std::int64_t> kinds)
        : modules{modules}, procs{procs}, blockId{blockId}, name{name},
          kinds{kinds} {}
 
    llvm::SmallVector<std::string> modules;
    llvm::SmallVector<std::string> procs;
    std::int64_t blockId;
    std::string name;
    llvm::SmallVector<std::int64_t> kinds;
  };

  static std::string doCommonBlock(llvm::StringRef name);

  static std::string doConstant(llvm::ArrayRef<llvm::StringRef> modules,
                                llvm::ArrayRef<llvm::StringRef> procs,
                                std::int64_t block, llvm::StringRef name);

  static std::string doDispatchTable(llvm::ArrayRef<llvm::StringRef> modules,
                                     llvm::ArrayRef<llvm::StringRef> procs,
                                     std::int64_t block, llvm::StringRef name,
                                     llvm::ArrayRef<std::int64_t> kinds);

  static std::string doGenerated(llvm::StringRef name);
  static std::string doGenerated(llvm::ArrayRef<llvm::StringRef> modules,
                                 llvm::ArrayRef<llvm::StringRef> procs,
                                 std::int64_t blockId, llvm::StringRef name);

  static std::string
  doIntrinsicTypeDescriptor(llvm::ArrayRef<llvm::StringRef> modules,
                            llvm::ArrayRef<llvm::StringRef> procs,
                            std::int64_t block, IntrinsicType type,
                            std::int64_t kind);

  static std::string doProcedure(llvm::ArrayRef<llvm::StringRef> modules,
                                 llvm::ArrayRef<llvm::StringRef> procs,
                                 llvm::StringRef name);

  static std::string doType(llvm::ArrayRef<llvm::StringRef> modules,
                            llvm::ArrayRef<llvm::StringRef> procs,
                            std::int64_t block, llvm::StringRef name,
                            llvm::ArrayRef<std::int64_t> kinds);

  static std::string doTypeDescriptor(llvm::ArrayRef<llvm::StringRef> modules,
                                      llvm::ArrayRef<llvm::StringRef> procs,
                                      std::int64_t block, llvm::StringRef name,
                                      llvm::ArrayRef<std::int64_t> kinds);
  static std::string doTypeDescriptor(llvm::ArrayRef<std::string> modules,
                                      llvm::ArrayRef<std::string> procs,
                                      std::int64_t block, llvm::StringRef name,
                                      llvm::ArrayRef<std::int64_t> kinds);

  static std::string doVariable(llvm::ArrayRef<llvm::StringRef> modules,
                                llvm::ArrayRef<llvm::StringRef> procs,
                                std::int64_t block, llvm::StringRef name);

  static std::string doNamelistGroup(llvm::ArrayRef<llvm::StringRef> modules,
                                     llvm::ArrayRef<llvm::StringRef> procs,
                                     llvm::StringRef name);

  static llvm::StringRef doProgramEntry();

  static std::pair<NameKind, DeconstructedName>
  deconstruct(llvm::StringRef uniquedName);

  static bool isExternalFacingUniquedName(
      const std::pair<NameKind, DeconstructedName> &deconstructResult);

  static bool needExternalNameMangling(llvm::StringRef uniquedName);

  static bool belongsToModule(llvm::StringRef uniquedName,
                              llvm::StringRef moduleName);

  static bool isModuleScopeDataUniquedName(llvm::StringRef uniquedName);

  static std::string getTypeDescriptorName(llvm::StringRef mangledTypeName);
 
  static std::string
  getTypeDescriptorAssemblyName(llvm::StringRef mangledTypeName);

  static std::string
  getTypeDescriptorBindingTableName(llvm::StringRef mangledTypeName);

  static std::string getComponentInitName(llvm::StringRef mangledTypeName,
                                          llvm::StringRef componentName);

  static llvm::StringRef
  dropTypeConversionMarkers(llvm::StringRef mangledTypeName);
 
  static std::string replaceSpecialSymbols(const std::string &name);

  static bool isSpecialSymbol(llvm::StringRef name);
 
private:
  static std::string intAsString(std::int64_t i);
  static std::string doKind(std::int64_t kind);
  static std::string doKinds(llvm::ArrayRef<std::int64_t> kinds);
  static std::string toLower(llvm::StringRef name);
 
  NameUniquer() = delete;
  NameUniquer(const NameUniquer &) = delete;
  NameUniquer(NameUniquer &&) = delete;
  NameUniquer &operator=(const NameUniquer &) = delete;
};
 
} // namespace fir
 
#endif // FORTRAN_OPTIMIZER_SUPPORT_INTERNALNAMES_H