ModuleUtils.cpp

Go to the documentation of this file.

//===--- ModuleUtils.cpp - Shared module emission queries -----------------===//
//
// 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 "clang/CodeGenUtils/ModuleUtils.h"
#include "clang/AST/Attr.h"
#include "clang/Basic/TargetInfo.h"
#include "llvm/ADT/SetVector.h"
 
namespace clang::CodeGenUtils {
 
LangAS getGlobalConstantAddressSpace(const LangOptions &LangOpts,
                                     const TargetInfo &Target) {
  // OpenCL v1.2 s6.5.3: a string literal is in the constant address space.
  if (LangOpts.OpenCL)
    return LangAS::opencl_constant;
  if (LangOpts.SYCLIsDevice)
    return LangAS::sycl_global;
  if (LangOpts.HIP && LangOpts.CUDAIsDevice && Target.getTriple().isSPIRV())
    // For HIPSPV map literals to cuda_device (maps to CrossWorkGroup in SPIR-V)
    // instead of default AS (maps to Generic in SPIR-V). Otherwise, we end up
    // with OpVariable instructions with Generic storage class which is not
    // allowed (SPIR-V V1.6 s3.42.8). Also, mapping literals to SPIR-V
    // UniformConstant storage class is not viable as pointers to it may not be
    // casted to Generic pointers which are used to model HIP's "flat" pointers.
    return LangAS::cuda_device;
  if (auto AS = Target.getConstantAddressSpace())
    return *AS;
  return LangAS::Default;
}
 
bool hasUnwindExceptions(const LangOptions &LangOpts) {
  // If exceptions are completely disabled, obviously this is false.
  if (!LangOpts.Exceptions)
    return false;
 
  // If C++ exceptions are enabled, this is true.
  if (LangOpts.CXXExceptions)
    return true;
 
  // If ObjC exceptions are enabled, this depends on the ABI.
  if (LangOpts.ObjCExceptions) {
    return LangOpts.ObjCRuntime.hasUnwindExceptions();
  }
 
  return true;
}
 
bool isVarDeclStrongDefinition(const ASTContext &Ctx, const VarDecl *D,
                               bool NoCommon) {
  // Don't give variables common linkage if -fno-common was specified unless it
  // was overridden by a NoCommon attribute.
  if ((NoCommon || D->hasAttr<NoCommonAttr>()) && !D->hasAttr<CommonAttr>())
    return true;
 
  // C11 6.9.2/2:
  //   A declaration of an identifier for an object that has file scope without
  //   an initializer, and without a storage-class specifier or with the
  //   storage-class specifier static, constitutes a tentative definition.
  if (D->getInit() || D->hasExternalStorage())
    return true;
 
  // A variable cannot be both common and exist in a section.
  if (D->hasAttr<SectionAttr>())
    return true;
 
  // A variable cannot be both common and exist in a section.
  // We don't try to determine which is the right section in the front-end.
  // If no specialized section name is applicable, it will resort to default.
  if (D->hasAttr<PragmaClangBSSSectionAttr>() ||
      D->hasAttr<PragmaClangDataSectionAttr>() ||
      D->hasAttr<PragmaClangRelroSectionAttr>() ||
      D->hasAttr<PragmaClangRodataSectionAttr>())
    return true;
 
  // Thread local vars aren't considered common linkage.
  if (D->getTLSKind())
    return true;
 
  // Tentative definitions marked with WeakImportAttr are true definitions.
  if (D->hasAttr<WeakImportAttr>())
    return true;
 
  // A variable cannot be both common and exist in a comdat.
  if (shouldBeInCOMDAT(Ctx, *D))
    return true;
 
  // Declarations with a required alignment do not have common linkage in MSVC
  // mode.
  if (Ctx.getTargetInfo().getCXXABI().isMicrosoft()) {
    if (D->hasAttr<AlignedAttr>())
      return true;
    QualType VarType = D->getType();
    if (Ctx.isAlignmentRequired(VarType))
      return true;
 
    if (const auto *RD = VarType->getAsRecordDecl()) {
      for (const FieldDecl *FD : RD->fields()) {
        if (FD->isBitField())
          continue;
        if (FD->hasAttr<AlignedAttr>())
          return true;
        if (Ctx.isAlignmentRequired(FD->getType()))
          return true;
      }
    }
  }
 
  // Microsoft's link.exe doesn't support alignments greater than 32 bytes for
  // common symbols, so symbols with greater alignment requirements cannot be
  // common.
  // Other COFF linkers (ld.bfd and LLD) support arbitrary power-of-two
  // alignments for common symbols via the aligncomm directive, so this
  // restriction only applies to MSVC environments.
  if (Ctx.getTargetInfo().getTriple().isKnownWindowsMSVCEnvironment() &&
      Ctx.getTypeAlignIfKnown(D->getType()) >
          Ctx.toBits(CharUnits::fromQuantity(32)))
    return true;
 
  return false;
}
 
bool shouldBeInCOMDAT(const ASTContext &Ctx, const Decl &D) {
  if (!Ctx.getTargetInfo().getTriple().supportsCOMDAT())
    return false;
 
  if (D.hasAttr<SelectAnyAttr>())
    return true;
 
  GVALinkage Linkage;
  if (auto *VD = dyn_cast<VarDecl>(&D))
    Linkage = Ctx.GetGVALinkageForVariable(VD);
  else
    Linkage = Ctx.GetGVALinkageForFunction(cast<FunctionDecl>(&D));
 
  switch (Linkage) {
  case GVA_Internal:
  case GVA_AvailableExternally:
  case GVA_StrongExternal:
    return false;
  case GVA_DiscardableODR:
  case GVA_StrongODR:
    return true;
  }
  llvm_unreachable("No such linkage");
}
 
llvm::SmallVector<Module *, 8>
importedModulesToInitialize(Module *Primary,
                            llvm::ArrayRef<Module *> Imported) {
  llvm::SmallSetVector<Module *, 8> Candidates;
  if (Primary && Primary->isInterfaceOrPartition()) {
    // The modules the unit exports.
    for (auto I : Primary->Exports)
      Candidates.insert(I.first);
    // The modules it only imports.
    Candidates.insert_range(Primary->Imports);
    // The modules it imports in the global module fragment or the private
    // module fragment.
    for (Module *SubM : Primary->submodules()) {
      assert(
          (SubM->isGlobalModule() || SubM->isPrivateModule()) &&
          "The sub modules of C++20 module unit should only be global module "
          "fragments or private module fragments.");
      assert(SubM->Exports.empty() &&
             "The global module fragments and the private module fragments are "
             "not allowed to export import modules.");
      Candidates.insert_range(SubM->Imports);
    }
  } else {
    Candidates.insert_range(Imported);
  }
 
  llvm::SmallVector<Module *, 8> Result;
  for (Module *M : Candidates) {
    // No Itanium initializer in header like modules.
    if (M->isHeaderLikeModule())
      continue;
    // The initialization may be skipped when it is sure to do nothing.
    if (!M->isNamedModuleInterfaceHasInit())
      continue;
    Result.push_back(M);
  }
  return Result;
}
 
} // namespace clang::CodeGenUtils