54f53c988d
This change introduces the #cir.global_view attribute and adds support for using that attribute to handle initializing a global variable with the address of another global variable. This does not yet include support for the optional list of indices to get an offset from the base address. Those will be added in a follow-up patch.
2147 lines
81 KiB
C++
2147 lines
81 KiB
C++
//===- CIRGenModule.cpp - Per-Module state for CIR generation -------------===//
|
|
//
|
|
// 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This is the internal per-translation-unit state used for CIR translation.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "CIRGenModule.h"
|
|
#include "CIRGenCXXABI.h"
|
|
#include "CIRGenConstantEmitter.h"
|
|
#include "CIRGenFunction.h"
|
|
|
|
#include "clang/AST/ASTContext.h"
|
|
#include "clang/AST/DeclBase.h"
|
|
#include "clang/AST/DeclOpenACC.h"
|
|
#include "clang/AST/GlobalDecl.h"
|
|
#include "clang/AST/RecordLayout.h"
|
|
#include "clang/Basic/SourceManager.h"
|
|
#include "clang/CIR/Dialect/IR/CIRDialect.h"
|
|
#include "clang/CIR/Interfaces/CIROpInterfaces.h"
|
|
#include "clang/CIR/MissingFeatures.h"
|
|
|
|
#include "CIRGenFunctionInfo.h"
|
|
#include "mlir/IR/BuiltinOps.h"
|
|
#include "mlir/IR/Location.h"
|
|
#include "mlir/IR/MLIRContext.h"
|
|
#include "mlir/IR/Verifier.h"
|
|
|
|
using namespace clang;
|
|
using namespace clang::CIRGen;
|
|
|
|
static CIRGenCXXABI *createCXXABI(CIRGenModule &cgm) {
|
|
switch (cgm.getASTContext().getCXXABIKind()) {
|
|
case TargetCXXABI::GenericItanium:
|
|
case TargetCXXABI::GenericAArch64:
|
|
case TargetCXXABI::AppleARM64:
|
|
return CreateCIRGenItaniumCXXABI(cgm);
|
|
|
|
case TargetCXXABI::Fuchsia:
|
|
case TargetCXXABI::GenericARM:
|
|
case TargetCXXABI::iOS:
|
|
case TargetCXXABI::WatchOS:
|
|
case TargetCXXABI::GenericMIPS:
|
|
case TargetCXXABI::WebAssembly:
|
|
case TargetCXXABI::XL:
|
|
case TargetCXXABI::Microsoft:
|
|
cgm.errorNYI("C++ ABI kind not yet implemented");
|
|
return nullptr;
|
|
}
|
|
|
|
llvm_unreachable("invalid C++ ABI kind");
|
|
}
|
|
|
|
CIRGenModule::CIRGenModule(mlir::MLIRContext &mlirContext,
|
|
clang::ASTContext &astContext,
|
|
const clang::CodeGenOptions &cgo,
|
|
DiagnosticsEngine &diags)
|
|
: builder(mlirContext, *this), astContext(astContext),
|
|
langOpts(astContext.getLangOpts()), codeGenOpts(cgo),
|
|
theModule{mlir::ModuleOp::create(mlir::UnknownLoc::get(&mlirContext))},
|
|
diags(diags), target(astContext.getTargetInfo()),
|
|
abi(createCXXABI(*this)), genTypes(*this), vtables(*this) {
|
|
|
|
// Initialize cached types
|
|
VoidTy = cir::VoidType::get(&getMLIRContext());
|
|
VoidPtrTy = cir::PointerType::get(VoidTy);
|
|
SInt8Ty = cir::IntType::get(&getMLIRContext(), 8, /*isSigned=*/true);
|
|
SInt16Ty = cir::IntType::get(&getMLIRContext(), 16, /*isSigned=*/true);
|
|
SInt32Ty = cir::IntType::get(&getMLIRContext(), 32, /*isSigned=*/true);
|
|
SInt64Ty = cir::IntType::get(&getMLIRContext(), 64, /*isSigned=*/true);
|
|
SInt128Ty = cir::IntType::get(&getMLIRContext(), 128, /*isSigned=*/true);
|
|
UInt8Ty = cir::IntType::get(&getMLIRContext(), 8, /*isSigned=*/false);
|
|
UInt8PtrTy = cir::PointerType::get(UInt8Ty);
|
|
UInt16Ty = cir::IntType::get(&getMLIRContext(), 16, /*isSigned=*/false);
|
|
UInt32Ty = cir::IntType::get(&getMLIRContext(), 32, /*isSigned=*/false);
|
|
UInt64Ty = cir::IntType::get(&getMLIRContext(), 64, /*isSigned=*/false);
|
|
UInt128Ty = cir::IntType::get(&getMLIRContext(), 128, /*isSigned=*/false);
|
|
FP16Ty = cir::FP16Type::get(&getMLIRContext());
|
|
BFloat16Ty = cir::BF16Type::get(&getMLIRContext());
|
|
FloatTy = cir::SingleType::get(&getMLIRContext());
|
|
DoubleTy = cir::DoubleType::get(&getMLIRContext());
|
|
FP80Ty = cir::FP80Type::get(&getMLIRContext());
|
|
FP128Ty = cir::FP128Type::get(&getMLIRContext());
|
|
|
|
PointerAlignInBytes =
|
|
astContext
|
|
.toCharUnitsFromBits(
|
|
astContext.getTargetInfo().getPointerAlign(LangAS::Default))
|
|
.getQuantity();
|
|
|
|
// TODO(CIR): Should be updated once TypeSizeInfoAttr is upstreamed
|
|
const unsigned sizeTypeSize =
|
|
astContext.getTypeSize(astContext.getSignedSizeType());
|
|
SizeAlignInBytes = astContext.toCharUnitsFromBits(sizeTypeSize).getQuantity();
|
|
// In CIRGenTypeCache, UIntPtrTy and SizeType are fields of the same union
|
|
UIntPtrTy =
|
|
cir::IntType::get(&getMLIRContext(), sizeTypeSize, /*isSigned=*/false);
|
|
PtrDiffTy =
|
|
cir::IntType::get(&getMLIRContext(), sizeTypeSize, /*isSigned=*/true);
|
|
|
|
theModule->setAttr(cir::CIRDialect::getTripleAttrName(),
|
|
builder.getStringAttr(getTriple().str()));
|
|
|
|
if (cgo.OptimizationLevel > 0 || cgo.OptimizeSize > 0)
|
|
theModule->setAttr(cir::CIRDialect::getOptInfoAttrName(),
|
|
cir::OptInfoAttr::get(&mlirContext,
|
|
cgo.OptimizationLevel,
|
|
cgo.OptimizeSize));
|
|
}
|
|
|
|
CIRGenModule::~CIRGenModule() = default;
|
|
|
|
/// FIXME: this could likely be a common helper and not necessarily related
|
|
/// with codegen.
|
|
/// Return the best known alignment for an unknown pointer to a
|
|
/// particular class.
|
|
CharUnits CIRGenModule::getClassPointerAlignment(const CXXRecordDecl *rd) {
|
|
if (!rd->hasDefinition())
|
|
return CharUnits::One(); // Hopefully won't be used anywhere.
|
|
|
|
auto &layout = astContext.getASTRecordLayout(rd);
|
|
|
|
// If the class is final, then we know that the pointer points to an
|
|
// object of that type and can use the full alignment.
|
|
if (rd->isEffectivelyFinal())
|
|
return layout.getAlignment();
|
|
|
|
// Otherwise, we have to assume it could be a subclass.
|
|
return layout.getNonVirtualAlignment();
|
|
}
|
|
|
|
CharUnits CIRGenModule::getNaturalTypeAlignment(QualType t,
|
|
LValueBaseInfo *baseInfo) {
|
|
assert(!cir::MissingFeatures::opTBAA());
|
|
|
|
// FIXME: This duplicates logic in ASTContext::getTypeAlignIfKnown, but
|
|
// that doesn't return the information we need to compute baseInfo.
|
|
|
|
// Honor alignment typedef attributes even on incomplete types.
|
|
// We also honor them straight for C++ class types, even as pointees;
|
|
// there's an expressivity gap here.
|
|
if (const auto *tt = t->getAs<TypedefType>()) {
|
|
if (unsigned align = tt->getDecl()->getMaxAlignment()) {
|
|
if (baseInfo)
|
|
*baseInfo = LValueBaseInfo(AlignmentSource::AttributedType);
|
|
return astContext.toCharUnitsFromBits(align);
|
|
}
|
|
}
|
|
|
|
// Analyze the base element type, so we don't get confused by incomplete
|
|
// array types.
|
|
t = astContext.getBaseElementType(t);
|
|
|
|
if (t->isIncompleteType()) {
|
|
// We could try to replicate the logic from
|
|
// ASTContext::getTypeAlignIfKnown, but nothing uses the alignment if the
|
|
// type is incomplete, so it's impossible to test. We could try to reuse
|
|
// getTypeAlignIfKnown, but that doesn't return the information we need
|
|
// to set baseInfo. So just ignore the possibility that the alignment is
|
|
// greater than one.
|
|
if (baseInfo)
|
|
*baseInfo = LValueBaseInfo(AlignmentSource::Type);
|
|
return CharUnits::One();
|
|
}
|
|
|
|
if (baseInfo)
|
|
*baseInfo = LValueBaseInfo(AlignmentSource::Type);
|
|
|
|
CharUnits alignment;
|
|
if (t.getQualifiers().hasUnaligned()) {
|
|
alignment = CharUnits::One();
|
|
} else {
|
|
assert(!cir::MissingFeatures::alignCXXRecordDecl());
|
|
alignment = astContext.getTypeAlignInChars(t);
|
|
}
|
|
|
|
// Cap to the global maximum type alignment unless the alignment
|
|
// was somehow explicit on the type.
|
|
if (unsigned maxAlign = astContext.getLangOpts().MaxTypeAlign) {
|
|
if (alignment.getQuantity() > maxAlign &&
|
|
!astContext.isAlignmentRequired(t))
|
|
alignment = CharUnits::fromQuantity(maxAlign);
|
|
}
|
|
return alignment;
|
|
}
|
|
|
|
const TargetCIRGenInfo &CIRGenModule::getTargetCIRGenInfo() {
|
|
if (theTargetCIRGenInfo)
|
|
return *theTargetCIRGenInfo;
|
|
|
|
const llvm::Triple &triple = getTarget().getTriple();
|
|
switch (triple.getArch()) {
|
|
default:
|
|
assert(!cir::MissingFeatures::targetCIRGenInfoArch());
|
|
|
|
// Currently we just fall through to x86_64.
|
|
[[fallthrough]];
|
|
|
|
case llvm::Triple::x86_64: {
|
|
switch (triple.getOS()) {
|
|
default:
|
|
assert(!cir::MissingFeatures::targetCIRGenInfoOS());
|
|
|
|
// Currently we just fall through to x86_64.
|
|
[[fallthrough]];
|
|
|
|
case llvm::Triple::Linux:
|
|
theTargetCIRGenInfo = createX8664TargetCIRGenInfo(genTypes);
|
|
return *theTargetCIRGenInfo;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
mlir::Location CIRGenModule::getLoc(SourceLocation cLoc) {
|
|
assert(cLoc.isValid() && "expected valid source location");
|
|
const SourceManager &sm = astContext.getSourceManager();
|
|
PresumedLoc pLoc = sm.getPresumedLoc(cLoc);
|
|
StringRef filename = pLoc.getFilename();
|
|
return mlir::FileLineColLoc::get(builder.getStringAttr(filename),
|
|
pLoc.getLine(), pLoc.getColumn());
|
|
}
|
|
|
|
mlir::Location CIRGenModule::getLoc(SourceRange cRange) {
|
|
assert(cRange.isValid() && "expected a valid source range");
|
|
mlir::Location begin = getLoc(cRange.getBegin());
|
|
mlir::Location end = getLoc(cRange.getEnd());
|
|
mlir::Attribute metadata;
|
|
return mlir::FusedLoc::get({begin, end}, metadata, builder.getContext());
|
|
}
|
|
|
|
mlir::Operation *
|
|
CIRGenModule::getAddrOfGlobal(GlobalDecl gd, ForDefinition_t isForDefinition) {
|
|
const Decl *d = gd.getDecl();
|
|
|
|
if (isa<CXXConstructorDecl>(d) || isa<CXXDestructorDecl>(d))
|
|
return getAddrOfCXXStructor(gd, /*FnInfo=*/nullptr, /*FnType=*/nullptr,
|
|
/*DontDefer=*/false, isForDefinition);
|
|
|
|
if (isa<CXXMethodDecl>(d)) {
|
|
const CIRGenFunctionInfo &fi =
|
|
getTypes().arrangeCXXMethodDeclaration(cast<CXXMethodDecl>(d));
|
|
cir::FuncType ty = getTypes().getFunctionType(fi);
|
|
return getAddrOfFunction(gd, ty, /*ForVTable=*/false, /*DontDefer=*/false,
|
|
isForDefinition);
|
|
}
|
|
|
|
if (isa<FunctionDecl>(d)) {
|
|
const CIRGenFunctionInfo &fi = getTypes().arrangeGlobalDeclaration(gd);
|
|
cir::FuncType ty = getTypes().getFunctionType(fi);
|
|
return getAddrOfFunction(gd, ty, /*ForVTable=*/false, /*DontDefer=*/false,
|
|
isForDefinition);
|
|
}
|
|
|
|
return getAddrOfGlobalVar(cast<VarDecl>(d), /*ty=*/nullptr, isForDefinition)
|
|
.getDefiningOp();
|
|
}
|
|
|
|
void CIRGenModule::emitGlobalDecl(const clang::GlobalDecl &d) {
|
|
// We call getAddrOfGlobal with isForDefinition set to ForDefinition in
|
|
// order to get a Value with exactly the type we need, not something that
|
|
// might have been created for another decl with the same mangled name but
|
|
// different type.
|
|
mlir::Operation *op = getAddrOfGlobal(d, ForDefinition);
|
|
|
|
// In case of different address spaces, we may still get a cast, even with
|
|
// IsForDefinition equal to ForDefinition. Query mangled names table to get
|
|
// GlobalValue.
|
|
if (!op)
|
|
op = getGlobalValue(getMangledName(d));
|
|
|
|
assert(op && "expected a valid global op");
|
|
|
|
// Check to see if we've already emitted this. This is necessary for a
|
|
// couple of reasons: first, decls can end up in deferred-decls queue
|
|
// multiple times, and second, decls can end up with definitions in unusual
|
|
// ways (e.g. by an extern inline function acquiring a strong function
|
|
// redefinition). Just ignore those cases.
|
|
// TODO: Not sure what to map this to for MLIR
|
|
mlir::Operation *globalValueOp = op;
|
|
if (auto gv = dyn_cast<cir::GetGlobalOp>(op))
|
|
globalValueOp =
|
|
mlir::SymbolTable::lookupSymbolIn(getModule(), gv.getNameAttr());
|
|
|
|
if (auto cirGlobalValue =
|
|
dyn_cast<cir::CIRGlobalValueInterface>(globalValueOp))
|
|
if (!cirGlobalValue.isDeclaration())
|
|
return;
|
|
|
|
// If this is OpenMP, check if it is legal to emit this global normally.
|
|
assert(!cir::MissingFeatures::openMP());
|
|
|
|
// Otherwise, emit the definition and move on to the next one.
|
|
emitGlobalDefinition(d, op);
|
|
}
|
|
|
|
void CIRGenModule::emitDeferred() {
|
|
// Emit code for any potentially referenced deferred decls. Since a previously
|
|
// unused static decl may become used during the generation of code for a
|
|
// static function, iterate until no changes are made.
|
|
|
|
assert(!cir::MissingFeatures::openMP());
|
|
assert(!cir::MissingFeatures::deferredVtables());
|
|
assert(!cir::MissingFeatures::cudaSupport());
|
|
|
|
// Stop if we're out of both deferred vtables and deferred declarations.
|
|
if (deferredDeclsToEmit.empty())
|
|
return;
|
|
|
|
// Grab the list of decls to emit. If emitGlobalDefinition schedules more
|
|
// work, it will not interfere with this.
|
|
std::vector<GlobalDecl> curDeclsToEmit;
|
|
curDeclsToEmit.swap(deferredDeclsToEmit);
|
|
|
|
for (const GlobalDecl &d : curDeclsToEmit) {
|
|
emitGlobalDecl(d);
|
|
|
|
// If we found out that we need to emit more decls, do that recursively.
|
|
// This has the advantage that the decls are emitted in a DFS and related
|
|
// ones are close together, which is convenient for testing.
|
|
if (!deferredDeclsToEmit.empty()) {
|
|
emitDeferred();
|
|
assert(deferredDeclsToEmit.empty());
|
|
}
|
|
}
|
|
}
|
|
|
|
void CIRGenModule::emitGlobal(clang::GlobalDecl gd) {
|
|
if (const auto *cd = dyn_cast<clang::OpenACCConstructDecl>(gd.getDecl())) {
|
|
emitGlobalOpenACCDecl(cd);
|
|
return;
|
|
}
|
|
|
|
const auto *global = cast<ValueDecl>(gd.getDecl());
|
|
|
|
if (const auto *fd = dyn_cast<FunctionDecl>(global)) {
|
|
// Update deferred annotations with the latest declaration if the function
|
|
// was already used or defined.
|
|
if (fd->hasAttr<AnnotateAttr>())
|
|
errorNYI(fd->getSourceRange(), "deferredAnnotations");
|
|
if (!fd->doesThisDeclarationHaveABody()) {
|
|
if (!fd->doesDeclarationForceExternallyVisibleDefinition())
|
|
return;
|
|
|
|
errorNYI(fd->getSourceRange(),
|
|
"function declaration that forces code gen");
|
|
return;
|
|
}
|
|
} else {
|
|
const auto *vd = cast<VarDecl>(global);
|
|
assert(vd->isFileVarDecl() && "Cannot emit local var decl as global.");
|
|
if (vd->isThisDeclarationADefinition() != VarDecl::Definition &&
|
|
!astContext.isMSStaticDataMemberInlineDefinition(vd)) {
|
|
assert(!cir::MissingFeatures::openMP());
|
|
// If this declaration may have caused an inline variable definition to
|
|
// change linkage, make sure that it's emitted.
|
|
if (astContext.getInlineVariableDefinitionKind(vd) ==
|
|
ASTContext::InlineVariableDefinitionKind::Strong)
|
|
getAddrOfGlobalVar(vd);
|
|
// Otherwise, we can ignore this declaration. The variable will be emitted
|
|
// on its first use.
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Defer code generation to first use when possible, e.g. if this is an inline
|
|
// function. If the global must always be emitted, do it eagerly if possible
|
|
// to benefit from cache locality. Deferring code generation is necessary to
|
|
// avoid adding initializers to external declarations.
|
|
if (mustBeEmitted(global) && mayBeEmittedEagerly(global)) {
|
|
// Emit the definition if it can't be deferred.
|
|
emitGlobalDefinition(gd);
|
|
return;
|
|
}
|
|
|
|
// If we're deferring emission of a C++ variable with an initializer, remember
|
|
// the order in which it appeared on the file.
|
|
assert(!cir::MissingFeatures::deferredCXXGlobalInit());
|
|
|
|
llvm::StringRef mangledName = getMangledName(gd);
|
|
if (getGlobalValue(mangledName) != nullptr) {
|
|
// The value has already been used and should therefore be emitted.
|
|
addDeferredDeclToEmit(gd);
|
|
} else if (mustBeEmitted(global)) {
|
|
// The value must be emitted, but cannot be emitted eagerly.
|
|
assert(!mayBeEmittedEagerly(global));
|
|
addDeferredDeclToEmit(gd);
|
|
} else {
|
|
// Otherwise, remember that we saw a deferred decl with this name. The first
|
|
// use of the mangled name will cause it to move into deferredDeclsToEmit.
|
|
deferredDecls[mangledName] = gd;
|
|
}
|
|
}
|
|
|
|
void CIRGenModule::emitGlobalFunctionDefinition(clang::GlobalDecl gd,
|
|
mlir::Operation *op) {
|
|
auto const *funcDecl = cast<FunctionDecl>(gd.getDecl());
|
|
const CIRGenFunctionInfo &fi = getTypes().arrangeGlobalDeclaration(gd);
|
|
cir::FuncType funcType = getTypes().getFunctionType(fi);
|
|
cir::FuncOp funcOp = dyn_cast_if_present<cir::FuncOp>(op);
|
|
if (!funcOp || funcOp.getFunctionType() != funcType) {
|
|
funcOp = getAddrOfFunction(gd, funcType, /*ForVTable=*/false,
|
|
/*DontDefer=*/true, ForDefinition);
|
|
}
|
|
|
|
// Already emitted.
|
|
if (!funcOp.isDeclaration())
|
|
return;
|
|
|
|
setFunctionLinkage(gd, funcOp);
|
|
setGVProperties(funcOp, funcDecl);
|
|
assert(!cir::MissingFeatures::opFuncMaybeHandleStaticInExternC());
|
|
maybeSetTrivialComdat(*funcDecl, funcOp);
|
|
assert(!cir::MissingFeatures::setLLVMFunctionFEnvAttributes());
|
|
|
|
CIRGenFunction cgf(*this, builder);
|
|
curCGF = &cgf;
|
|
{
|
|
mlir::OpBuilder::InsertionGuard guard(builder);
|
|
cgf.generateCode(gd, funcOp, funcType);
|
|
}
|
|
curCGF = nullptr;
|
|
|
|
setNonAliasAttributes(gd, funcOp);
|
|
assert(!cir::MissingFeatures::opFuncAttributesForDefinition());
|
|
|
|
if (funcDecl->getAttr<ConstructorAttr>())
|
|
errorNYI(funcDecl->getSourceRange(), "constructor attribute");
|
|
if (funcDecl->getAttr<DestructorAttr>())
|
|
errorNYI(funcDecl->getSourceRange(), "destructor attribute");
|
|
|
|
if (funcDecl->getAttr<AnnotateAttr>())
|
|
errorNYI(funcDecl->getSourceRange(), "deferredAnnotations");
|
|
}
|
|
|
|
mlir::Operation *CIRGenModule::getGlobalValue(StringRef name) {
|
|
return mlir::SymbolTable::lookupSymbolIn(theModule, name);
|
|
}
|
|
|
|
cir::GlobalOp CIRGenModule::createGlobalOp(CIRGenModule &cgm,
|
|
mlir::Location loc, StringRef name,
|
|
mlir::Type t,
|
|
mlir::Operation *insertPoint) {
|
|
cir::GlobalOp g;
|
|
CIRGenBuilderTy &builder = cgm.getBuilder();
|
|
|
|
{
|
|
mlir::OpBuilder::InsertionGuard guard(builder);
|
|
|
|
// If an insertion point is provided, we're replacing an existing global,
|
|
// otherwise, create the new global immediately after the last gloabl we
|
|
// emitted.
|
|
if (insertPoint) {
|
|
builder.setInsertionPoint(insertPoint);
|
|
} else {
|
|
// Group global operations together at the top of the module.
|
|
if (cgm.lastGlobalOp)
|
|
builder.setInsertionPointAfter(cgm.lastGlobalOp);
|
|
else
|
|
builder.setInsertionPointToStart(cgm.getModule().getBody());
|
|
}
|
|
|
|
g = builder.create<cir::GlobalOp>(loc, name, t);
|
|
if (!insertPoint)
|
|
cgm.lastGlobalOp = g;
|
|
|
|
// Default to private until we can judge based on the initializer,
|
|
// since MLIR doesn't allow public declarations.
|
|
mlir::SymbolTable::setSymbolVisibility(
|
|
g, mlir::SymbolTable::Visibility::Private);
|
|
}
|
|
return g;
|
|
}
|
|
|
|
void CIRGenModule::setCommonAttributes(GlobalDecl gd, mlir::Operation *gv) {
|
|
const Decl *d = gd.getDecl();
|
|
if (isa_and_nonnull<NamedDecl>(d))
|
|
setGVProperties(gv, dyn_cast<NamedDecl>(d));
|
|
assert(!cir::MissingFeatures::defaultVisibility());
|
|
assert(!cir::MissingFeatures::opGlobalUsedOrCompilerUsed());
|
|
}
|
|
|
|
void CIRGenModule::setNonAliasAttributes(GlobalDecl gd, mlir::Operation *op) {
|
|
setCommonAttributes(gd, op);
|
|
|
|
assert(!cir::MissingFeatures::opGlobalUsedOrCompilerUsed());
|
|
assert(!cir::MissingFeatures::opGlobalSection());
|
|
assert(!cir::MissingFeatures::opFuncCPUAndFeaturesAttributes());
|
|
assert(!cir::MissingFeatures::opFuncSection());
|
|
|
|
assert(!cir::MissingFeatures::setTargetAttributes());
|
|
}
|
|
|
|
static void setLinkageForGV(cir::GlobalOp &gv, const NamedDecl *nd) {
|
|
// Set linkage and visibility in case we never see a definition.
|
|
LinkageInfo lv = nd->getLinkageAndVisibility();
|
|
// Don't set internal linkage on declarations.
|
|
// "extern_weak" is overloaded in LLVM; we probably should have
|
|
// separate linkage types for this.
|
|
if (isExternallyVisible(lv.getLinkage()) &&
|
|
(nd->hasAttr<WeakAttr>() || nd->isWeakImported()))
|
|
gv.setLinkage(cir::GlobalLinkageKind::ExternalWeakLinkage);
|
|
}
|
|
|
|
/// If the specified mangled name is not in the module,
|
|
/// create and return an mlir GlobalOp with the specified type (TODO(cir):
|
|
/// address space).
|
|
///
|
|
/// TODO(cir):
|
|
/// 1. If there is something in the module with the specified name, return
|
|
/// it potentially bitcasted to the right type.
|
|
///
|
|
/// 2. If \p d is non-null, it specifies a decl that correspond to this. This
|
|
/// is used to set the attributes on the global when it is first created.
|
|
///
|
|
/// 3. If \p isForDefinition is true, it is guaranteed that an actual global
|
|
/// with type \p ty will be returned, not conversion of a variable with the same
|
|
/// mangled name but some other type.
|
|
cir::GlobalOp
|
|
CIRGenModule::getOrCreateCIRGlobal(StringRef mangledName, mlir::Type ty,
|
|
LangAS langAS, const VarDecl *d,
|
|
ForDefinition_t isForDefinition) {
|
|
// Lookup the entry, lazily creating it if necessary.
|
|
cir::GlobalOp entry;
|
|
if (mlir::Operation *v = getGlobalValue(mangledName)) {
|
|
if (!isa<cir::GlobalOp>(v))
|
|
errorNYI(d->getSourceRange(), "global with non-GlobalOp type");
|
|
entry = cast<cir::GlobalOp>(v);
|
|
}
|
|
|
|
if (entry) {
|
|
assert(!cir::MissingFeatures::addressSpace());
|
|
assert(!cir::MissingFeatures::opGlobalWeakRef());
|
|
|
|
assert(!cir::MissingFeatures::setDLLStorageClass());
|
|
assert(!cir::MissingFeatures::openMP());
|
|
|
|
if (entry.getSymType() == ty)
|
|
return entry;
|
|
|
|
// If there are two attempts to define the same mangled name, issue an
|
|
// error.
|
|
//
|
|
// TODO(cir): look at mlir::GlobalValue::isDeclaration for all aspects of
|
|
// recognizing the global as a declaration, for now only check if
|
|
// initializer is present.
|
|
if (isForDefinition && !entry.isDeclaration()) {
|
|
errorNYI(d->getSourceRange(), "global with conflicting type");
|
|
}
|
|
|
|
// Address space check removed because it is unnecessary because CIR records
|
|
// address space info in types.
|
|
|
|
// (If global is requested for a definition, we always need to create a new
|
|
// global, not just return a bitcast.)
|
|
if (!isForDefinition)
|
|
return entry;
|
|
}
|
|
|
|
mlir::Location loc = getLoc(d->getSourceRange());
|
|
|
|
// mlir::SymbolTable::Visibility::Public is the default, no need to explicitly
|
|
// mark it as such.
|
|
cir::GlobalOp gv =
|
|
CIRGenModule::createGlobalOp(*this, loc, mangledName, ty,
|
|
/*insertPoint=*/entry.getOperation());
|
|
|
|
// This is the first use or definition of a mangled name. If there is a
|
|
// deferred decl with this name, remember that we need to emit it at the end
|
|
// of the file.
|
|
auto ddi = deferredDecls.find(mangledName);
|
|
if (ddi != deferredDecls.end()) {
|
|
// Move the potentially referenced deferred decl to the DeferredDeclsToEmit
|
|
// list, and remove it from DeferredDecls (since we don't need it anymore).
|
|
addDeferredDeclToEmit(ddi->second);
|
|
deferredDecls.erase(ddi);
|
|
}
|
|
|
|
// Handle things which are present even on external declarations.
|
|
if (d) {
|
|
if (langOpts.OpenMP && !langOpts.OpenMPSimd)
|
|
errorNYI(d->getSourceRange(), "OpenMP target global variable");
|
|
|
|
gv.setAlignmentAttr(getSize(astContext.getDeclAlign(d)));
|
|
assert(!cir::MissingFeatures::opGlobalConstant());
|
|
|
|
setLinkageForGV(gv, d);
|
|
|
|
if (d->getTLSKind())
|
|
errorNYI(d->getSourceRange(), "thread local global variable");
|
|
|
|
setGVProperties(gv, d);
|
|
|
|
// If required by the ABI, treat declarations of static data members with
|
|
// inline initializers as definitions.
|
|
if (astContext.isMSStaticDataMemberInlineDefinition(d))
|
|
errorNYI(d->getSourceRange(), "MS static data member inline definition");
|
|
|
|
assert(!cir::MissingFeatures::opGlobalSection());
|
|
gv.setGlobalVisibilityAttr(getGlobalVisibilityAttrFromDecl(d));
|
|
|
|
// Handle XCore specific ABI requirements.
|
|
if (getTriple().getArch() == llvm::Triple::xcore)
|
|
errorNYI(d->getSourceRange(), "XCore specific ABI requirements");
|
|
|
|
// Check if we a have a const declaration with an initializer, we may be
|
|
// able to emit it as available_externally to expose it's value to the
|
|
// optimizer.
|
|
if (getLangOpts().CPlusPlus && gv.isPublic() &&
|
|
d->getType().isConstQualified() && gv.isDeclaration() &&
|
|
!d->hasDefinition() && d->hasInit() && !d->hasAttr<DLLImportAttr>())
|
|
errorNYI(d->getSourceRange(),
|
|
"external const declaration with initializer");
|
|
}
|
|
|
|
return gv;
|
|
}
|
|
|
|
cir::GlobalOp
|
|
CIRGenModule::getOrCreateCIRGlobal(const VarDecl *d, mlir::Type ty,
|
|
ForDefinition_t isForDefinition) {
|
|
assert(d->hasGlobalStorage() && "Not a global variable");
|
|
QualType astTy = d->getType();
|
|
if (!ty)
|
|
ty = getTypes().convertTypeForMem(astTy);
|
|
|
|
StringRef mangledName = getMangledName(d);
|
|
return getOrCreateCIRGlobal(mangledName, ty, astTy.getAddressSpace(), d,
|
|
isForDefinition);
|
|
}
|
|
|
|
/// Return the mlir::Value for the address of the given global variable. If
|
|
/// \p ty is non-null and if the global doesn't exist, then it will be created
|
|
/// with the specified type instead of whatever the normal requested type would
|
|
/// be. If \p isForDefinition is true, it is guaranteed that an actual global
|
|
/// with type \p ty will be returned, not conversion of a variable with the same
|
|
/// mangled name but some other type.
|
|
mlir::Value CIRGenModule::getAddrOfGlobalVar(const VarDecl *d, mlir::Type ty,
|
|
ForDefinition_t isForDefinition) {
|
|
assert(d->hasGlobalStorage() && "Not a global variable");
|
|
QualType astTy = d->getType();
|
|
if (!ty)
|
|
ty = getTypes().convertTypeForMem(astTy);
|
|
|
|
assert(!cir::MissingFeatures::opGlobalThreadLocal());
|
|
|
|
cir::GlobalOp g = getOrCreateCIRGlobal(d, ty, isForDefinition);
|
|
mlir::Type ptrTy = builder.getPointerTo(g.getSymType());
|
|
return builder.create<cir::GetGlobalOp>(getLoc(d->getSourceRange()), ptrTy,
|
|
g.getSymName());
|
|
}
|
|
|
|
cir::GlobalViewAttr CIRGenModule::getAddrOfGlobalVarAttr(const VarDecl *d) {
|
|
assert(d->hasGlobalStorage() && "Not a global variable");
|
|
mlir::Type ty = getTypes().convertTypeForMem(d->getType());
|
|
|
|
cir::GlobalOp globalOp = getOrCreateCIRGlobal(d, ty, NotForDefinition);
|
|
assert(!cir::MissingFeatures::addressSpace());
|
|
cir::PointerType ptrTy = builder.getPointerTo(globalOp.getSymType());
|
|
return builder.getGlobalViewAttr(ptrTy, globalOp);
|
|
}
|
|
|
|
void CIRGenModule::emitGlobalVarDefinition(const clang::VarDecl *vd,
|
|
bool isTentative) {
|
|
if (getLangOpts().OpenCL || getLangOpts().OpenMPIsTargetDevice) {
|
|
errorNYI(vd->getSourceRange(), "emit OpenCL/OpenMP global variable");
|
|
return;
|
|
}
|
|
|
|
// Whether the definition of the variable is available externally.
|
|
// If yes, we shouldn't emit the GloablCtor and GlobalDtor for the variable
|
|
// since this is the job for its original source.
|
|
bool isDefinitionAvailableExternally =
|
|
astContext.GetGVALinkageForVariable(vd) == GVA_AvailableExternally;
|
|
assert(!cir::MissingFeatures::needsGlobalCtorDtor());
|
|
|
|
// It is useless to emit the definition for an available_externally variable
|
|
// which can't be marked as const.
|
|
if (isDefinitionAvailableExternally &&
|
|
(!vd->hasConstantInitialization() ||
|
|
// TODO: Update this when we have interface to check constexpr
|
|
// destructor.
|
|
vd->needsDestruction(astContext) ||
|
|
!vd->getType().isConstantStorage(astContext, true, true)))
|
|
return;
|
|
|
|
mlir::Attribute init;
|
|
const VarDecl *initDecl;
|
|
const Expr *initExpr = vd->getAnyInitializer(initDecl);
|
|
|
|
std::optional<ConstantEmitter> emitter;
|
|
|
|
assert(!cir::MissingFeatures::cudaSupport());
|
|
|
|
if (vd->hasAttr<LoaderUninitializedAttr>()) {
|
|
errorNYI(vd->getSourceRange(), "loader uninitialized attribute");
|
|
return;
|
|
} else if (!initExpr) {
|
|
// This is a tentative definition; tentative definitions are
|
|
// implicitly initialized with { 0 }.
|
|
//
|
|
// Note that tentative definitions are only emitted at the end of
|
|
// a translation unit, so they should never have incomplete
|
|
// type. In addition, EmitTentativeDefinition makes sure that we
|
|
// never attempt to emit a tentative definition if a real one
|
|
// exists. A use may still exists, however, so we still may need
|
|
// to do a RAUW.
|
|
assert(!vd->getType()->isIncompleteType() && "Unexpected incomplete type");
|
|
init = builder.getZeroInitAttr(convertType(vd->getType()));
|
|
} else {
|
|
emitter.emplace(*this);
|
|
mlir::Attribute initializer = emitter->tryEmitForInitializer(*initDecl);
|
|
if (!initializer) {
|
|
QualType qt = initExpr->getType();
|
|
if (vd->getType()->isReferenceType())
|
|
qt = vd->getType();
|
|
|
|
if (getLangOpts().CPlusPlus) {
|
|
if (initDecl->hasFlexibleArrayInit(astContext))
|
|
errorNYI(vd->getSourceRange(), "flexible array initializer");
|
|
init = builder.getZeroInitAttr(convertType(qt));
|
|
if (astContext.GetGVALinkageForVariable(vd) != GVA_AvailableExternally)
|
|
errorNYI(vd->getSourceRange(), "global constructor");
|
|
} else {
|
|
errorNYI(vd->getSourceRange(), "static initializer");
|
|
}
|
|
} else {
|
|
init = initializer;
|
|
// We don't need an initializer, so remove the entry for the delayed
|
|
// initializer position (just in case this entry was delayed) if we
|
|
// also don't need to register a destructor.
|
|
if (vd->needsDestruction(astContext) == QualType::DK_cxx_destructor)
|
|
errorNYI(vd->getSourceRange(), "delayed destructor");
|
|
}
|
|
}
|
|
|
|
mlir::Type initType;
|
|
if (mlir::isa<mlir::SymbolRefAttr>(init)) {
|
|
errorNYI(vd->getSourceRange(), "global initializer is a symbol reference");
|
|
return;
|
|
} else {
|
|
assert(mlir::isa<mlir::TypedAttr>(init) && "This should have a type");
|
|
auto typedInitAttr = mlir::cast<mlir::TypedAttr>(init);
|
|
initType = typedInitAttr.getType();
|
|
}
|
|
assert(!mlir::isa<mlir::NoneType>(initType) && "Should have a type by now");
|
|
|
|
cir::GlobalOp gv =
|
|
getOrCreateCIRGlobal(vd, initType, ForDefinition_t(!isTentative));
|
|
// TODO(cir): Strip off pointer casts from Entry if we get them?
|
|
|
|
if (!gv || gv.getSymType() != initType) {
|
|
errorNYI(vd->getSourceRange(), "global initializer with type mismatch");
|
|
return;
|
|
}
|
|
|
|
assert(!cir::MissingFeatures::maybeHandleStaticInExternC());
|
|
|
|
if (vd->hasAttr<AnnotateAttr>()) {
|
|
errorNYI(vd->getSourceRange(), "annotate global variable");
|
|
}
|
|
|
|
if (langOpts.CUDA) {
|
|
errorNYI(vd->getSourceRange(), "CUDA global variable");
|
|
}
|
|
|
|
// Set initializer and finalize emission
|
|
CIRGenModule::setInitializer(gv, init);
|
|
if (emitter)
|
|
emitter->finalize(gv);
|
|
|
|
// Set CIR's linkage type as appropriate.
|
|
cir::GlobalLinkageKind linkage =
|
|
getCIRLinkageVarDefinition(vd, /*IsConstant=*/false);
|
|
|
|
// Set CIR linkage and DLL storage class.
|
|
gv.setLinkage(linkage);
|
|
// FIXME(cir): setLinkage should likely set MLIR's visibility automatically.
|
|
gv.setVisibility(getMLIRVisibilityFromCIRLinkage(linkage));
|
|
assert(!cir::MissingFeatures::opGlobalDLLImportExport());
|
|
if (linkage == cir::GlobalLinkageKind::CommonLinkage)
|
|
errorNYI(initExpr->getSourceRange(), "common linkage");
|
|
|
|
setNonAliasAttributes(vd, gv);
|
|
|
|
assert(!cir::MissingFeatures::opGlobalThreadLocal());
|
|
|
|
maybeSetTrivialComdat(*vd, gv);
|
|
}
|
|
|
|
void CIRGenModule::emitGlobalDefinition(clang::GlobalDecl gd,
|
|
mlir::Operation *op) {
|
|
const auto *decl = cast<ValueDecl>(gd.getDecl());
|
|
if (const auto *fd = dyn_cast<FunctionDecl>(decl)) {
|
|
// TODO(CIR): Skip generation of CIR for functions with available_externally
|
|
// linkage at -O0.
|
|
|
|
if (const auto *method = dyn_cast<CXXMethodDecl>(decl)) {
|
|
// Make sure to emit the definition(s) before we emit the thunks. This is
|
|
// necessary for the generation of certain thunks.
|
|
if (isa<CXXConstructorDecl>(method) || isa<CXXDestructorDecl>(method))
|
|
abi->emitCXXStructor(gd);
|
|
else if (fd->isMultiVersion())
|
|
errorNYI(method->getSourceRange(), "multiversion functions");
|
|
else
|
|
emitGlobalFunctionDefinition(gd, op);
|
|
|
|
if (method->isVirtual())
|
|
errorNYI(method->getSourceRange(), "virtual member function");
|
|
|
|
return;
|
|
}
|
|
|
|
if (fd->isMultiVersion())
|
|
errorNYI(fd->getSourceRange(), "multiversion functions");
|
|
emitGlobalFunctionDefinition(gd, op);
|
|
return;
|
|
}
|
|
|
|
if (const auto *vd = dyn_cast<VarDecl>(decl))
|
|
return emitGlobalVarDefinition(vd, !vd->hasDefinition());
|
|
|
|
llvm_unreachable("Invalid argument to CIRGenModule::emitGlobalDefinition");
|
|
}
|
|
|
|
mlir::Attribute
|
|
CIRGenModule::getConstantArrayFromStringLiteral(const StringLiteral *e) {
|
|
assert(!e->getType()->isPointerType() && "Strings are always arrays");
|
|
|
|
// Don't emit it as the address of the string, emit the string data itself
|
|
// as an inline array.
|
|
if (e->getCharByteWidth() == 1) {
|
|
SmallString<64> str(e->getString());
|
|
|
|
// Resize the string to the right size, which is indicated by its type.
|
|
const ConstantArrayType *cat =
|
|
astContext.getAsConstantArrayType(e->getType());
|
|
uint64_t finalSize = cat->getZExtSize();
|
|
str.resize(finalSize);
|
|
|
|
mlir::Type eltTy = convertType(cat->getElementType());
|
|
return builder.getString(str, eltTy, finalSize);
|
|
}
|
|
|
|
errorNYI(e->getSourceRange(),
|
|
"getConstantArrayFromStringLiteral: wide characters");
|
|
return mlir::Attribute();
|
|
}
|
|
|
|
bool CIRGenModule::supportsCOMDAT() const {
|
|
return getTriple().supportsCOMDAT();
|
|
}
|
|
|
|
static bool shouldBeInCOMDAT(CIRGenModule &cgm, const Decl &d) {
|
|
if (!cgm.supportsCOMDAT())
|
|
return false;
|
|
|
|
if (d.hasAttr<SelectAnyAttr>())
|
|
return true;
|
|
|
|
GVALinkage linkage;
|
|
if (auto *vd = dyn_cast<VarDecl>(&d))
|
|
linkage = cgm.getASTContext().GetGVALinkageForVariable(vd);
|
|
else
|
|
linkage =
|
|
cgm.getASTContext().GetGVALinkageForFunction(cast<FunctionDecl>(&d));
|
|
|
|
switch (linkage) {
|
|
case clang::GVA_Internal:
|
|
case clang::GVA_AvailableExternally:
|
|
case clang::GVA_StrongExternal:
|
|
return false;
|
|
case clang::GVA_DiscardableODR:
|
|
case clang::GVA_StrongODR:
|
|
return true;
|
|
}
|
|
llvm_unreachable("No such linkage");
|
|
}
|
|
|
|
void CIRGenModule::maybeSetTrivialComdat(const Decl &d, mlir::Operation *op) {
|
|
if (!shouldBeInCOMDAT(*this, d))
|
|
return;
|
|
if (auto globalOp = dyn_cast_or_null<cir::GlobalOp>(op)) {
|
|
globalOp.setComdat(true);
|
|
} else {
|
|
auto funcOp = cast<cir::FuncOp>(op);
|
|
funcOp.setComdat(true);
|
|
}
|
|
}
|
|
|
|
void CIRGenModule::updateCompletedType(const TagDecl *td) {
|
|
// Make sure that this type is translated.
|
|
genTypes.updateCompletedType(td);
|
|
}
|
|
|
|
void CIRGenModule::addReplacement(StringRef name, mlir::Operation *op) {
|
|
replacements[name] = op;
|
|
}
|
|
|
|
void CIRGenModule::replacePointerTypeArgs(cir::FuncOp oldF, cir::FuncOp newF) {
|
|
std::optional<mlir::SymbolTable::UseRange> optionalUseRange =
|
|
oldF.getSymbolUses(theModule);
|
|
if (!optionalUseRange)
|
|
return;
|
|
|
|
for (const mlir::SymbolTable::SymbolUse &u : *optionalUseRange) {
|
|
// CallTryOp only shows up after FlattenCFG.
|
|
auto call = mlir::dyn_cast<cir::CallOp>(u.getUser());
|
|
if (!call)
|
|
continue;
|
|
|
|
for (const auto [argOp, fnArgType] :
|
|
llvm::zip(call.getArgs(), newF.getFunctionType().getInputs())) {
|
|
if (argOp.getType() == fnArgType)
|
|
continue;
|
|
|
|
// The purpose of this entire function is to insert bitcasts in the case
|
|
// where these types don't match, but I haven't seen a case where that
|
|
// happens.
|
|
errorNYI(call.getLoc(), "replace call with mismatched types");
|
|
}
|
|
}
|
|
}
|
|
|
|
void CIRGenModule::applyReplacements() {
|
|
for (auto &i : replacements) {
|
|
StringRef mangledName = i.first();
|
|
mlir::Operation *replacement = i.second;
|
|
mlir::Operation *entry = getGlobalValue(mangledName);
|
|
if (!entry)
|
|
continue;
|
|
assert(isa<cir::FuncOp>(entry) && "expected function");
|
|
auto oldF = cast<cir::FuncOp>(entry);
|
|
auto newF = dyn_cast<cir::FuncOp>(replacement);
|
|
if (!newF) {
|
|
// In classic codegen, this can be a global alias, a bitcast, or a GEP.
|
|
errorNYI(replacement->getLoc(), "replacement is not a function");
|
|
continue;
|
|
}
|
|
|
|
// LLVM has opaque pointer but CIR not. So we may have to handle these
|
|
// different pointer types when performing replacement.
|
|
replacePointerTypeArgs(oldF, newF);
|
|
|
|
// Replace old with new, but keep the old order.
|
|
if (oldF.replaceAllSymbolUses(newF.getSymNameAttr(), theModule).failed())
|
|
llvm_unreachable("internal error, cannot RAUW symbol");
|
|
if (newF) {
|
|
newF->moveBefore(oldF);
|
|
oldF->erase();
|
|
}
|
|
}
|
|
}
|
|
|
|
cir::GlobalOp CIRGenModule::createOrReplaceCXXRuntimeVariable(
|
|
mlir::Location loc, StringRef name, mlir::Type ty,
|
|
cir::GlobalLinkageKind linkage, clang::CharUnits alignment) {
|
|
auto gv = mlir::dyn_cast_or_null<cir::GlobalOp>(
|
|
mlir::SymbolTable::lookupSymbolIn(theModule, name));
|
|
|
|
if (gv) {
|
|
// There should be handling added here to check the type as assert that
|
|
// gv was a declaration if the type doesn't match and handling below
|
|
// to replace the variable if it was a declaration.
|
|
errorNYI(loc, "createOrReplaceCXXRuntimeVariable: already exists");
|
|
return gv;
|
|
}
|
|
|
|
// Create a new variable.
|
|
gv = createGlobalOp(*this, loc, name, ty);
|
|
|
|
// Set up extra information and add to the module
|
|
gv.setLinkageAttr(
|
|
cir::GlobalLinkageKindAttr::get(&getMLIRContext(), linkage));
|
|
mlir::SymbolTable::setSymbolVisibility(gv,
|
|
CIRGenModule::getMLIRVisibility(gv));
|
|
|
|
if (supportsCOMDAT() && cir::isWeakForLinker(linkage) &&
|
|
!gv.hasAvailableExternallyLinkage()) {
|
|
gv.setComdat(true);
|
|
}
|
|
|
|
gv.setAlignmentAttr(getSize(alignment));
|
|
setDSOLocal(static_cast<mlir::Operation *>(gv));
|
|
return gv;
|
|
}
|
|
|
|
// TODO(CIR): this could be a common method between LLVM codegen.
|
|
static bool isVarDeclStrongDefinition(const ASTContext &astContext,
|
|
CIRGenModule &cgm, const VarDecl *vd,
|
|
bool noCommon) {
|
|
// Don't give variables common linkage if -fno-common was specified unless it
|
|
// was overridden by a NoCommon attribute.
|
|
if ((noCommon || vd->hasAttr<NoCommonAttr>()) && !vd->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 (vd->getInit() || vd->hasExternalStorage())
|
|
return true;
|
|
|
|
// A variable cannot be both common and exist in a section.
|
|
if (vd->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 (vd->hasAttr<PragmaClangBSSSectionAttr>() ||
|
|
vd->hasAttr<PragmaClangDataSectionAttr>() ||
|
|
vd->hasAttr<PragmaClangRelroSectionAttr>() ||
|
|
vd->hasAttr<PragmaClangRodataSectionAttr>())
|
|
return true;
|
|
|
|
// Thread local vars aren't considered common linkage.
|
|
if (vd->getTLSKind())
|
|
return true;
|
|
|
|
// Tentative definitions marked with WeakImportAttr are true definitions.
|
|
if (vd->hasAttr<WeakImportAttr>())
|
|
return true;
|
|
|
|
// A variable cannot be both common and exist in a comdat.
|
|
if (shouldBeInCOMDAT(cgm, *vd))
|
|
return true;
|
|
|
|
// Declarations with a required alignment do not have common linkage in MSVC
|
|
// mode.
|
|
if (astContext.getTargetInfo().getCXXABI().isMicrosoft()) {
|
|
if (vd->hasAttr<AlignedAttr>())
|
|
return true;
|
|
QualType varType = vd->getType();
|
|
if (astContext.isAlignmentRequired(varType))
|
|
return true;
|
|
|
|
if (const auto *rt = varType->getAs<RecordType>()) {
|
|
const RecordDecl *rd = rt->getOriginalDecl()->getDefinitionOrSelf();
|
|
for (const FieldDecl *fd : rd->fields()) {
|
|
if (fd->isBitField())
|
|
continue;
|
|
if (fd->hasAttr<AlignedAttr>())
|
|
return true;
|
|
if (astContext.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 (astContext.getTargetInfo().getTriple().isKnownWindowsMSVCEnvironment() &&
|
|
astContext.getTypeAlignIfKnown(vd->getType()) >
|
|
astContext.toBits(CharUnits::fromQuantity(32)))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
cir::GlobalLinkageKind CIRGenModule::getCIRLinkageForDeclarator(
|
|
const DeclaratorDecl *dd, GVALinkage linkage, bool isConstantVariable) {
|
|
if (linkage == GVA_Internal)
|
|
return cir::GlobalLinkageKind::InternalLinkage;
|
|
|
|
if (dd->hasAttr<WeakAttr>()) {
|
|
if (isConstantVariable)
|
|
return cir::GlobalLinkageKind::WeakODRLinkage;
|
|
return cir::GlobalLinkageKind::WeakAnyLinkage;
|
|
}
|
|
|
|
if (const auto *fd = dd->getAsFunction())
|
|
if (fd->isMultiVersion() && linkage == GVA_AvailableExternally)
|
|
return cir::GlobalLinkageKind::LinkOnceAnyLinkage;
|
|
|
|
// We are guaranteed to have a strong definition somewhere else,
|
|
// so we can use available_externally linkage.
|
|
if (linkage == GVA_AvailableExternally)
|
|
return cir::GlobalLinkageKind::AvailableExternallyLinkage;
|
|
|
|
// Note that Apple's kernel linker doesn't support symbol
|
|
// coalescing, so we need to avoid linkonce and weak linkages there.
|
|
// Normally, this means we just map to internal, but for explicit
|
|
// instantiations we'll map to external.
|
|
|
|
// In C++, the compiler has to emit a definition in every translation unit
|
|
// that references the function. We should use linkonce_odr because
|
|
// a) if all references in this translation unit are optimized away, we
|
|
// don't need to codegen it. b) if the function persists, it needs to be
|
|
// merged with other definitions. c) C++ has the ODR, so we know the
|
|
// definition is dependable.
|
|
if (linkage == GVA_DiscardableODR)
|
|
return !astContext.getLangOpts().AppleKext
|
|
? cir::GlobalLinkageKind::LinkOnceODRLinkage
|
|
: cir::GlobalLinkageKind::InternalLinkage;
|
|
|
|
// An explicit instantiation of a template has weak linkage, since
|
|
// explicit instantiations can occur in multiple translation units
|
|
// and must all be equivalent. However, we are not allowed to
|
|
// throw away these explicit instantiations.
|
|
//
|
|
// CUDA/HIP: For -fno-gpu-rdc case, device code is limited to one TU,
|
|
// so say that CUDA templates are either external (for kernels) or internal.
|
|
// This lets llvm perform aggressive inter-procedural optimizations. For
|
|
// -fgpu-rdc case, device function calls across multiple TU's are allowed,
|
|
// therefore we need to follow the normal linkage paradigm.
|
|
if (linkage == GVA_StrongODR) {
|
|
if (getLangOpts().AppleKext)
|
|
return cir::GlobalLinkageKind::ExternalLinkage;
|
|
if (getLangOpts().CUDA && getLangOpts().CUDAIsDevice &&
|
|
!getLangOpts().GPURelocatableDeviceCode)
|
|
return dd->hasAttr<CUDAGlobalAttr>()
|
|
? cir::GlobalLinkageKind::ExternalLinkage
|
|
: cir::GlobalLinkageKind::InternalLinkage;
|
|
return cir::GlobalLinkageKind::WeakODRLinkage;
|
|
}
|
|
|
|
// C++ doesn't have tentative definitions and thus cannot have common
|
|
// linkage.
|
|
if (!getLangOpts().CPlusPlus && isa<VarDecl>(dd) &&
|
|
!isVarDeclStrongDefinition(astContext, *this, cast<VarDecl>(dd),
|
|
getCodeGenOpts().NoCommon)) {
|
|
errorNYI(dd->getBeginLoc(), "common linkage", dd->getDeclKindName());
|
|
return cir::GlobalLinkageKind::CommonLinkage;
|
|
}
|
|
|
|
// selectany symbols are externally visible, so use weak instead of
|
|
// linkonce. MSVC optimizes away references to const selectany globals, so
|
|
// all definitions should be the same and ODR linkage should be used.
|
|
// http://msdn.microsoft.com/en-us/library/5tkz6s71.aspx
|
|
if (dd->hasAttr<SelectAnyAttr>())
|
|
return cir::GlobalLinkageKind::WeakODRLinkage;
|
|
|
|
// Otherwise, we have strong external linkage.
|
|
assert(linkage == GVA_StrongExternal);
|
|
return cir::GlobalLinkageKind::ExternalLinkage;
|
|
}
|
|
|
|
/// This function is called when we implement a function with no prototype, e.g.
|
|
/// "int foo() {}". If there are existing call uses of the old function in the
|
|
/// module, this adjusts them to call the new function directly.
|
|
///
|
|
/// This is not just a cleanup: the always_inline pass requires direct calls to
|
|
/// functions to be able to inline them. If there is a bitcast in the way, it
|
|
/// won't inline them. Instcombine normally deletes these calls, but it isn't
|
|
/// run at -O0.
|
|
void CIRGenModule::replaceUsesOfNonProtoTypeWithRealFunction(
|
|
mlir::Operation *old, cir::FuncOp newFn) {
|
|
// If we're redefining a global as a function, don't transform it.
|
|
auto oldFn = mlir::dyn_cast<cir::FuncOp>(old);
|
|
if (!oldFn)
|
|
return;
|
|
|
|
// TODO(cir): this RAUW ignores the features below.
|
|
assert(!cir::MissingFeatures::opFuncExceptions());
|
|
assert(!cir::MissingFeatures::opFuncParameterAttributes());
|
|
assert(!cir::MissingFeatures::opFuncOperandBundles());
|
|
if (oldFn->getAttrs().size() <= 1)
|
|
errorNYI(old->getLoc(),
|
|
"replaceUsesOfNonProtoTypeWithRealFunction: Attribute forwarding");
|
|
|
|
// Mark new function as originated from a no-proto declaration.
|
|
newFn.setNoProto(oldFn.getNoProto());
|
|
|
|
// Iterate through all calls of the no-proto function.
|
|
std::optional<mlir::SymbolTable::UseRange> symUses =
|
|
oldFn.getSymbolUses(oldFn->getParentOp());
|
|
for (const mlir::SymbolTable::SymbolUse &use : symUses.value()) {
|
|
mlir::OpBuilder::InsertionGuard guard(builder);
|
|
|
|
if (auto noProtoCallOp = mlir::dyn_cast<cir::CallOp>(use.getUser())) {
|
|
builder.setInsertionPoint(noProtoCallOp);
|
|
|
|
// Patch call type with the real function type.
|
|
cir::CallOp realCallOp = builder.createCallOp(
|
|
noProtoCallOp.getLoc(), newFn, noProtoCallOp.getOperands());
|
|
|
|
// Replace old no proto call with fixed call.
|
|
noProtoCallOp.replaceAllUsesWith(realCallOp);
|
|
noProtoCallOp.erase();
|
|
} else if (auto getGlobalOp =
|
|
mlir::dyn_cast<cir::GetGlobalOp>(use.getUser())) {
|
|
// Replace type
|
|
getGlobalOp.getAddr().setType(
|
|
cir::PointerType::get(newFn.getFunctionType()));
|
|
} else {
|
|
errorNYI(use.getUser()->getLoc(),
|
|
"replaceUsesOfNonProtoTypeWithRealFunction: unexpected use");
|
|
}
|
|
}
|
|
}
|
|
|
|
cir::GlobalLinkageKind
|
|
CIRGenModule::getCIRLinkageVarDefinition(const VarDecl *vd, bool isConstant) {
|
|
assert(!isConstant && "constant variables NYI");
|
|
GVALinkage linkage = astContext.GetGVALinkageForVariable(vd);
|
|
return getCIRLinkageForDeclarator(vd, linkage, isConstant);
|
|
}
|
|
|
|
cir::GlobalLinkageKind CIRGenModule::getFunctionLinkage(GlobalDecl gd) {
|
|
const auto *d = cast<FunctionDecl>(gd.getDecl());
|
|
|
|
GVALinkage linkage = astContext.GetGVALinkageForFunction(d);
|
|
|
|
if (const auto *dtor = dyn_cast<CXXDestructorDecl>(d))
|
|
return getCXXABI().getCXXDestructorLinkage(linkage, dtor, gd.getDtorType());
|
|
|
|
return getCIRLinkageForDeclarator(d, linkage, /*isConstantVariable=*/false);
|
|
}
|
|
|
|
static cir::GlobalOp
|
|
generateStringLiteral(mlir::Location loc, mlir::TypedAttr c,
|
|
cir::GlobalLinkageKind lt, CIRGenModule &cgm,
|
|
StringRef globalName, CharUnits alignment) {
|
|
assert(!cir::MissingFeatures::addressSpace());
|
|
|
|
// Create a global variable for this string
|
|
// FIXME(cir): check for insertion point in module level.
|
|
cir::GlobalOp gv =
|
|
CIRGenModule::createGlobalOp(cgm, loc, globalName, c.getType());
|
|
|
|
// Set up extra information and add to the module
|
|
gv.setAlignmentAttr(cgm.getSize(alignment));
|
|
gv.setLinkageAttr(
|
|
cir::GlobalLinkageKindAttr::get(cgm.getBuilder().getContext(), lt));
|
|
assert(!cir::MissingFeatures::opGlobalThreadLocal());
|
|
assert(!cir::MissingFeatures::opGlobalUnnamedAddr());
|
|
CIRGenModule::setInitializer(gv, c);
|
|
if (gv.isWeakForLinker()) {
|
|
assert(cgm.supportsCOMDAT() && "Only COFF uses weak string literals");
|
|
gv.setComdat(true);
|
|
}
|
|
cgm.setDSOLocal(static_cast<mlir::Operation *>(gv));
|
|
return gv;
|
|
}
|
|
|
|
// LLVM IR automatically uniques names when new llvm::GlobalVariables are
|
|
// created. This is handy, for example, when creating globals for string
|
|
// literals. Since we don't do that when creating cir::GlobalOp's, we need
|
|
// a mechanism to generate a unique name in advance.
|
|
//
|
|
// For now, this mechanism is only used in cases where we know that the
|
|
// name is compiler-generated, so we don't use the MLIR symbol table for
|
|
// the lookup.
|
|
std::string CIRGenModule::getUniqueGlobalName(const std::string &baseName) {
|
|
// If this is the first time we've generated a name for this basename, use
|
|
// it as is and start a counter for this base name.
|
|
auto it = cgGlobalNames.find(baseName);
|
|
if (it == cgGlobalNames.end()) {
|
|
cgGlobalNames[baseName] = 1;
|
|
return baseName;
|
|
}
|
|
|
|
std::string result =
|
|
baseName + "." + std::to_string(cgGlobalNames[baseName]++);
|
|
// There should not be any symbol with this name in the module.
|
|
assert(!mlir::SymbolTable::lookupSymbolIn(theModule, result));
|
|
return result;
|
|
}
|
|
|
|
/// Return a pointer to a constant array for the given string literal.
|
|
cir::GlobalOp CIRGenModule::getGlobalForStringLiteral(const StringLiteral *s,
|
|
StringRef name) {
|
|
CharUnits alignment =
|
|
astContext.getAlignOfGlobalVarInChars(s->getType(), /*VD=*/nullptr);
|
|
|
|
mlir::Attribute c = getConstantArrayFromStringLiteral(s);
|
|
|
|
if (getLangOpts().WritableStrings) {
|
|
errorNYI(s->getSourceRange(),
|
|
"getGlobalForStringLiteral: Writable strings");
|
|
}
|
|
|
|
// Mangle the string literal if that's how the ABI merges duplicate strings.
|
|
// Don't do it if they are writable, since we don't want writes in one TU to
|
|
// affect strings in another.
|
|
if (getCXXABI().getMangleContext().shouldMangleStringLiteral(s) &&
|
|
!getLangOpts().WritableStrings) {
|
|
errorNYI(s->getSourceRange(),
|
|
"getGlobalForStringLiteral: mangle string literals");
|
|
}
|
|
|
|
// Unlike LLVM IR, CIR doesn't automatically unique names for globals, so
|
|
// we need to do that explicitly.
|
|
std::string uniqueName = getUniqueGlobalName(name.str());
|
|
mlir::Location loc = getLoc(s->getSourceRange());
|
|
auto typedC = llvm::cast<mlir::TypedAttr>(c);
|
|
cir::GlobalOp gv =
|
|
generateStringLiteral(loc, typedC, cir::GlobalLinkageKind::PrivateLinkage,
|
|
*this, uniqueName, alignment);
|
|
setDSOLocal(static_cast<mlir::Operation *>(gv));
|
|
|
|
assert(!cir::MissingFeatures::sanitizers());
|
|
|
|
return gv;
|
|
}
|
|
|
|
void CIRGenModule::emitExplicitCastExprType(const ExplicitCastExpr *e,
|
|
CIRGenFunction *cgf) {
|
|
if (cgf && e->getType()->isVariablyModifiedType())
|
|
cgf->emitVariablyModifiedType(e->getType());
|
|
|
|
assert(!cir::MissingFeatures::generateDebugInfo() &&
|
|
"emitExplicitCastExprType");
|
|
}
|
|
|
|
void CIRGenModule::emitDeclContext(const DeclContext *dc) {
|
|
for (Decl *decl : dc->decls()) {
|
|
// Unlike other DeclContexts, the contents of an ObjCImplDecl at TU scope
|
|
// are themselves considered "top-level", so EmitTopLevelDecl on an
|
|
// ObjCImplDecl does not recursively visit them. We need to do that in
|
|
// case they're nested inside another construct (LinkageSpecDecl /
|
|
// ExportDecl) that does stop them from being considered "top-level".
|
|
if (auto *oid = dyn_cast<ObjCImplDecl>(decl))
|
|
errorNYI(oid->getSourceRange(), "emitDeclConext: ObjCImplDecl");
|
|
|
|
emitTopLevelDecl(decl);
|
|
}
|
|
}
|
|
|
|
// Emit code for a single top level declaration.
|
|
void CIRGenModule::emitTopLevelDecl(Decl *decl) {
|
|
|
|
// Ignore dependent declarations.
|
|
if (decl->isTemplated())
|
|
return;
|
|
|
|
switch (decl->getKind()) {
|
|
default:
|
|
errorNYI(decl->getBeginLoc(), "declaration of kind",
|
|
decl->getDeclKindName());
|
|
break;
|
|
|
|
case Decl::CXXConversion:
|
|
case Decl::CXXMethod:
|
|
case Decl::Function: {
|
|
auto *fd = cast<FunctionDecl>(decl);
|
|
// Consteval functions shouldn't be emitted.
|
|
if (!fd->isConsteval())
|
|
emitGlobal(fd);
|
|
break;
|
|
}
|
|
|
|
case Decl::Var:
|
|
case Decl::Decomposition:
|
|
case Decl::VarTemplateSpecialization: {
|
|
auto *vd = cast<VarDecl>(decl);
|
|
if (isa<DecompositionDecl>(decl)) {
|
|
errorNYI(decl->getSourceRange(), "global variable decompositions");
|
|
break;
|
|
}
|
|
emitGlobal(vd);
|
|
break;
|
|
}
|
|
case Decl::OpenACCRoutine:
|
|
emitGlobalOpenACCDecl(cast<OpenACCRoutineDecl>(decl));
|
|
break;
|
|
case Decl::OpenACCDeclare:
|
|
emitGlobalOpenACCDecl(cast<OpenACCDeclareDecl>(decl));
|
|
break;
|
|
case Decl::Enum:
|
|
case Decl::Using: // using X; [C++]
|
|
case Decl::UsingDirective: // using namespace X; [C++]
|
|
case Decl::UsingEnum: // using enum X; [C++]
|
|
case Decl::NamespaceAlias:
|
|
case Decl::Typedef:
|
|
case Decl::TypeAlias: // using foo = bar; [C++11]
|
|
case Decl::Record:
|
|
assert(!cir::MissingFeatures::generateDebugInfo());
|
|
break;
|
|
|
|
// No code generation needed.
|
|
case Decl::ClassTemplate:
|
|
case Decl::Concept:
|
|
case Decl::CXXDeductionGuide:
|
|
case Decl::Empty:
|
|
case Decl::FunctionTemplate:
|
|
case Decl::StaticAssert:
|
|
case Decl::TypeAliasTemplate:
|
|
case Decl::UsingShadow:
|
|
case Decl::VarTemplate:
|
|
case Decl::VarTemplatePartialSpecialization:
|
|
break;
|
|
|
|
case Decl::CXXConstructor:
|
|
getCXXABI().emitCXXConstructors(cast<CXXConstructorDecl>(decl));
|
|
break;
|
|
case Decl::CXXDestructor:
|
|
getCXXABI().emitCXXDestructors(cast<CXXDestructorDecl>(decl));
|
|
break;
|
|
|
|
// C++ Decls
|
|
case Decl::LinkageSpec:
|
|
case Decl::Namespace:
|
|
emitDeclContext(Decl::castToDeclContext(decl));
|
|
break;
|
|
|
|
case Decl::ClassTemplateSpecialization:
|
|
case Decl::CXXRecord:
|
|
assert(!cir::MissingFeatures::generateDebugInfo());
|
|
assert(!cir::MissingFeatures::cxxRecordStaticMembers());
|
|
break;
|
|
|
|
case Decl::FileScopeAsm:
|
|
// File-scope asm is ignored during device-side CUDA compilation.
|
|
if (langOpts.CUDA && langOpts.CUDAIsDevice)
|
|
break;
|
|
// File-scope asm is ignored during device-side OpenMP compilation.
|
|
if (langOpts.OpenMPIsTargetDevice)
|
|
break;
|
|
// File-scope asm is ignored during device-side SYCL compilation.
|
|
if (langOpts.SYCLIsDevice)
|
|
break;
|
|
auto *file_asm = cast<FileScopeAsmDecl>(decl);
|
|
std::string line = file_asm->getAsmString();
|
|
globalScopeAsm.push_back(builder.getStringAttr(line));
|
|
break;
|
|
}
|
|
}
|
|
|
|
void CIRGenModule::setInitializer(cir::GlobalOp &op, mlir::Attribute value) {
|
|
// Recompute visibility when updating initializer.
|
|
op.setInitialValueAttr(value);
|
|
assert(!cir::MissingFeatures::opGlobalVisibility());
|
|
}
|
|
|
|
std::pair<cir::FuncType, cir::FuncOp> CIRGenModule::getAddrAndTypeOfCXXStructor(
|
|
GlobalDecl gd, const CIRGenFunctionInfo *fnInfo, cir::FuncType fnType,
|
|
bool dontDefer, ForDefinition_t isForDefinition) {
|
|
auto *md = cast<CXXMethodDecl>(gd.getDecl());
|
|
|
|
if (isa<CXXDestructorDecl>(md)) {
|
|
// Always alias equivalent complete destructors to base destructors in the
|
|
// MS ABI.
|
|
if (getTarget().getCXXABI().isMicrosoft() &&
|
|
gd.getDtorType() == Dtor_Complete &&
|
|
md->getParent()->getNumVBases() == 0)
|
|
errorNYI(md->getSourceRange(),
|
|
"getAddrAndTypeOfCXXStructor: MS ABI complete destructor");
|
|
}
|
|
|
|
if (!fnType) {
|
|
if (!fnInfo)
|
|
fnInfo = &getTypes().arrangeCXXStructorDeclaration(gd);
|
|
fnType = getTypes().getFunctionType(*fnInfo);
|
|
}
|
|
|
|
auto fn = getOrCreateCIRFunction(getMangledName(gd), fnType, gd,
|
|
/*ForVtable=*/false, dontDefer,
|
|
/*IsThunk=*/false, isForDefinition);
|
|
|
|
return {fnType, fn};
|
|
}
|
|
|
|
cir::FuncOp CIRGenModule::getAddrOfFunction(clang::GlobalDecl gd,
|
|
mlir::Type funcType, bool forVTable,
|
|
bool dontDefer,
|
|
ForDefinition_t isForDefinition) {
|
|
assert(!cast<FunctionDecl>(gd.getDecl())->isConsteval() &&
|
|
"consteval function should never be emitted");
|
|
|
|
if (!funcType) {
|
|
const auto *fd = cast<FunctionDecl>(gd.getDecl());
|
|
funcType = convertType(fd->getType());
|
|
}
|
|
|
|
// Devirtualized destructor calls may come through here instead of via
|
|
// getAddrOfCXXStructor. Make sure we use the MS ABI base destructor instead
|
|
// of the complete destructor when necessary.
|
|
if (const auto *dd = dyn_cast<CXXDestructorDecl>(gd.getDecl())) {
|
|
if (getTarget().getCXXABI().isMicrosoft() &&
|
|
gd.getDtorType() == Dtor_Complete &&
|
|
dd->getParent()->getNumVBases() == 0)
|
|
errorNYI(dd->getSourceRange(),
|
|
"getAddrOfFunction: MS ABI complete destructor");
|
|
}
|
|
|
|
StringRef mangledName = getMangledName(gd);
|
|
cir::FuncOp func =
|
|
getOrCreateCIRFunction(mangledName, funcType, gd, forVTable, dontDefer,
|
|
/*isThunk=*/false, isForDefinition);
|
|
return func;
|
|
}
|
|
|
|
static std::string getMangledNameImpl(CIRGenModule &cgm, GlobalDecl gd,
|
|
const NamedDecl *nd) {
|
|
SmallString<256> buffer;
|
|
|
|
llvm::raw_svector_ostream out(buffer);
|
|
MangleContext &mc = cgm.getCXXABI().getMangleContext();
|
|
|
|
assert(!cir::MissingFeatures::moduleNameHash());
|
|
|
|
if (mc.shouldMangleDeclName(nd)) {
|
|
mc.mangleName(gd.getWithDecl(nd), out);
|
|
} else {
|
|
IdentifierInfo *ii = nd->getIdentifier();
|
|
assert(ii && "Attempt to mangle unnamed decl.");
|
|
|
|
const auto *fd = dyn_cast<FunctionDecl>(nd);
|
|
if (fd &&
|
|
fd->getType()->castAs<FunctionType>()->getCallConv() == CC_X86RegCall) {
|
|
cgm.errorNYI(nd->getSourceRange(), "getMangledName: X86RegCall");
|
|
} else if (fd && fd->hasAttr<CUDAGlobalAttr>() &&
|
|
gd.getKernelReferenceKind() == KernelReferenceKind::Stub) {
|
|
cgm.errorNYI(nd->getSourceRange(), "getMangledName: CUDA device stub");
|
|
}
|
|
out << ii->getName();
|
|
}
|
|
|
|
// Check if the module name hash should be appended for internal linkage
|
|
// symbols. This should come before multi-version target suffixes are
|
|
// appendded. This is to keep the name and module hash suffix of the internal
|
|
// linkage function together. The unique suffix should only be added when name
|
|
// mangling is done to make sure that the final name can be properly
|
|
// demangled. For example, for C functions without prototypes, name mangling
|
|
// is not done and the unique suffix should not be appended then.
|
|
assert(!cir::MissingFeatures::moduleNameHash());
|
|
|
|
if (const auto *fd = dyn_cast<FunctionDecl>(nd)) {
|
|
if (fd->isMultiVersion()) {
|
|
cgm.errorNYI(nd->getSourceRange(),
|
|
"getMangledName: multi-version functions");
|
|
}
|
|
}
|
|
if (cgm.getLangOpts().GPURelocatableDeviceCode) {
|
|
cgm.errorNYI(nd->getSourceRange(),
|
|
"getMangledName: GPU relocatable device code");
|
|
}
|
|
|
|
return std::string(out.str());
|
|
}
|
|
|
|
StringRef CIRGenModule::getMangledName(GlobalDecl gd) {
|
|
GlobalDecl canonicalGd = gd.getCanonicalDecl();
|
|
|
|
// Some ABIs don't have constructor variants. Make sure that base and complete
|
|
// constructors get mangled the same.
|
|
if (const auto *cd = dyn_cast<CXXConstructorDecl>(canonicalGd.getDecl())) {
|
|
if (!getTarget().getCXXABI().hasConstructorVariants()) {
|
|
errorNYI(cd->getSourceRange(),
|
|
"getMangledName: C++ constructor without variants");
|
|
return cast<NamedDecl>(gd.getDecl())->getIdentifier()->getName();
|
|
}
|
|
}
|
|
|
|
// Keep the first result in the case of a mangling collision.
|
|
const auto *nd = cast<NamedDecl>(gd.getDecl());
|
|
std::string mangledName = getMangledNameImpl(*this, gd, nd);
|
|
|
|
auto result = manglings.insert(std::make_pair(mangledName, gd));
|
|
return mangledDeclNames[canonicalGd] = result.first->first();
|
|
}
|
|
|
|
void CIRGenModule::emitTentativeDefinition(const VarDecl *d) {
|
|
assert(!d->getInit() && "Cannot emit definite definitions here!");
|
|
|
|
StringRef mangledName = getMangledName(d);
|
|
mlir::Operation *gv = getGlobalValue(mangledName);
|
|
|
|
// If we already have a definition, not declaration, with the same mangled
|
|
// name, emitting of declaration is not required (and would actually overwrite
|
|
// the emitted definition).
|
|
if (gv && !mlir::cast<cir::GlobalOp>(gv).isDeclaration())
|
|
return;
|
|
|
|
// If we have not seen a reference to this variable yet, place it into the
|
|
// deferred declarations table to be emitted if needed later.
|
|
if (!mustBeEmitted(d) && !gv) {
|
|
deferredDecls[mangledName] = d;
|
|
return;
|
|
}
|
|
|
|
// The tentative definition is the only definition.
|
|
emitGlobalVarDefinition(d);
|
|
}
|
|
|
|
bool CIRGenModule::mustBeEmitted(const ValueDecl *global) {
|
|
// Never defer when EmitAllDecls is specified.
|
|
if (langOpts.EmitAllDecls)
|
|
return true;
|
|
|
|
const auto *vd = dyn_cast<VarDecl>(global);
|
|
if (vd &&
|
|
((codeGenOpts.KeepPersistentStorageVariables &&
|
|
(vd->getStorageDuration() == SD_Static ||
|
|
vd->getStorageDuration() == SD_Thread)) ||
|
|
(codeGenOpts.KeepStaticConsts && vd->getStorageDuration() == SD_Static &&
|
|
vd->getType().isConstQualified())))
|
|
return true;
|
|
|
|
return getASTContext().DeclMustBeEmitted(global);
|
|
}
|
|
|
|
bool CIRGenModule::mayBeEmittedEagerly(const ValueDecl *global) {
|
|
// In OpenMP 5.0 variables and function may be marked as
|
|
// device_type(host/nohost) and we should not emit them eagerly unless we sure
|
|
// that they must be emitted on the host/device. To be sure we need to have
|
|
// seen a declare target with an explicit mentioning of the function, we know
|
|
// we have if the level of the declare target attribute is -1. Note that we
|
|
// check somewhere else if we should emit this at all.
|
|
if (langOpts.OpenMP >= 50 && !langOpts.OpenMPSimd) {
|
|
std::optional<OMPDeclareTargetDeclAttr *> activeAttr =
|
|
OMPDeclareTargetDeclAttr::getActiveAttr(global);
|
|
if (!activeAttr || (*activeAttr)->getLevel() != (unsigned)-1)
|
|
return false;
|
|
}
|
|
|
|
const auto *fd = dyn_cast<FunctionDecl>(global);
|
|
if (fd) {
|
|
// Implicit template instantiations may change linkage if they are later
|
|
// explicitly instantiated, so they should not be emitted eagerly.
|
|
if (fd->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
|
|
return false;
|
|
// Defer until all versions have been semantically checked.
|
|
if (fd->hasAttr<TargetVersionAttr>() && !fd->isMultiVersion())
|
|
return false;
|
|
if (langOpts.SYCLIsDevice) {
|
|
errorNYI(fd->getSourceRange(), "mayBeEmittedEagerly: SYCL");
|
|
return false;
|
|
}
|
|
}
|
|
const auto *vd = dyn_cast<VarDecl>(global);
|
|
if (vd)
|
|
if (astContext.getInlineVariableDefinitionKind(vd) ==
|
|
ASTContext::InlineVariableDefinitionKind::WeakUnknown)
|
|
// A definition of an inline constexpr static data member may change
|
|
// linkage later if it's redeclared outside the class.
|
|
return false;
|
|
|
|
// If OpenMP is enabled and threadprivates must be generated like TLS, delay
|
|
// codegen for global variables, because they may be marked as threadprivate.
|
|
if (langOpts.OpenMP && langOpts.OpenMPUseTLS &&
|
|
astContext.getTargetInfo().isTLSSupported() && isa<VarDecl>(global) &&
|
|
!global->getType().isConstantStorage(astContext, false, false) &&
|
|
!OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(global))
|
|
return false;
|
|
|
|
assert((fd || vd) &&
|
|
"Only FunctionDecl and VarDecl should hit this path so far.");
|
|
return true;
|
|
}
|
|
|
|
static bool shouldAssumeDSOLocal(const CIRGenModule &cgm,
|
|
cir::CIRGlobalValueInterface gv) {
|
|
if (gv.hasLocalLinkage())
|
|
return true;
|
|
|
|
if (!gv.hasDefaultVisibility() && !gv.hasExternalWeakLinkage())
|
|
return true;
|
|
|
|
// DLLImport explicitly marks the GV as external.
|
|
// so it shouldn't be dso_local
|
|
// But we don't have the info set now
|
|
assert(!cir::MissingFeatures::opGlobalDLLImportExport());
|
|
|
|
const llvm::Triple &tt = cgm.getTriple();
|
|
const CodeGenOptions &cgOpts = cgm.getCodeGenOpts();
|
|
if (tt.isOSCygMing()) {
|
|
// In MinGW and Cygwin, variables without DLLImport can still be
|
|
// automatically imported from a DLL by the linker; don't mark variables
|
|
// that potentially could come from another DLL as DSO local.
|
|
|
|
// With EmulatedTLS, TLS variables can be autoimported from other DLLs
|
|
// (and this actually happens in the public interface of libstdc++), so
|
|
// such variables can't be marked as DSO local. (Native TLS variables
|
|
// can't be dllimported at all, though.)
|
|
cgm.errorNYI("shouldAssumeDSOLocal: MinGW");
|
|
}
|
|
|
|
// On COFF, don't mark 'extern_weak' symbols as DSO local. If these symbols
|
|
// remain unresolved in the link, they can be resolved to zero, which is
|
|
// outside the current DSO.
|
|
if (tt.isOSBinFormatCOFF() && gv.hasExternalWeakLinkage())
|
|
return false;
|
|
|
|
// Every other GV is local on COFF.
|
|
// Make an exception for windows OS in the triple: Some firmware builds use
|
|
// *-win32-macho triples. This (accidentally?) produced windows relocations
|
|
// without GOT tables in older clang versions; Keep this behaviour.
|
|
// FIXME: even thread local variables?
|
|
if (tt.isOSBinFormatCOFF() || (tt.isOSWindows() && tt.isOSBinFormatMachO()))
|
|
return true;
|
|
|
|
// Only handle COFF and ELF for now.
|
|
if (!tt.isOSBinFormatELF())
|
|
return false;
|
|
|
|
llvm::Reloc::Model rm = cgOpts.RelocationModel;
|
|
const LangOptions &lOpts = cgm.getLangOpts();
|
|
if (rm != llvm::Reloc::Static && !lOpts.PIE) {
|
|
// On ELF, if -fno-semantic-interposition is specified and the target
|
|
// supports local aliases, there will be neither CC1
|
|
// -fsemantic-interposition nor -fhalf-no-semantic-interposition. Set
|
|
// dso_local on the function if using a local alias is preferable (can avoid
|
|
// PLT indirection).
|
|
if (!(isa<cir::FuncOp>(gv) && gv.canBenefitFromLocalAlias()))
|
|
return false;
|
|
return !(lOpts.SemanticInterposition || lOpts.HalfNoSemanticInterposition);
|
|
}
|
|
|
|
// A definition cannot be preempted from an executable.
|
|
if (!gv.isDeclarationForLinker())
|
|
return true;
|
|
|
|
// Most PIC code sequences that assume that a symbol is local cannot produce a
|
|
// 0 if it turns out the symbol is undefined. While this is ABI and relocation
|
|
// depended, it seems worth it to handle it here.
|
|
if (rm == llvm::Reloc::PIC_ && gv.hasExternalWeakLinkage())
|
|
return false;
|
|
|
|
// PowerPC64 prefers TOC indirection to avoid copy relocations.
|
|
if (tt.isPPC64())
|
|
return false;
|
|
|
|
if (cgOpts.DirectAccessExternalData) {
|
|
// If -fdirect-access-external-data (default for -fno-pic), set dso_local
|
|
// for non-thread-local variables. If the symbol is not defined in the
|
|
// executable, a copy relocation will be needed at link time. dso_local is
|
|
// excluded for thread-local variables because they generally don't support
|
|
// copy relocations.
|
|
if (auto globalOp = dyn_cast<cir::GlobalOp>(gv.getOperation())) {
|
|
// Assume variables are not thread-local until that support is added.
|
|
assert(!cir::MissingFeatures::opGlobalThreadLocal());
|
|
return true;
|
|
}
|
|
|
|
// -fno-pic sets dso_local on a function declaration to allow direct
|
|
// accesses when taking its address (similar to a data symbol). If the
|
|
// function is not defined in the executable, a canonical PLT entry will be
|
|
// needed at link time. -fno-direct-access-external-data can avoid the
|
|
// canonical PLT entry. We don't generalize this condition to -fpie/-fpic as
|
|
// it could just cause trouble without providing perceptible benefits.
|
|
if (isa<cir::FuncOp>(gv) && !cgOpts.NoPLT && rm == llvm::Reloc::Static)
|
|
return true;
|
|
}
|
|
|
|
// If we can use copy relocations we can assume it is local.
|
|
|
|
// Otherwise don't assume it is local.
|
|
|
|
return false;
|
|
}
|
|
|
|
void CIRGenModule::setGlobalVisibility(mlir::Operation *gv,
|
|
const NamedDecl *d) const {
|
|
assert(!cir::MissingFeatures::opGlobalVisibility());
|
|
}
|
|
|
|
void CIRGenModule::setDSOLocal(cir::CIRGlobalValueInterface gv) const {
|
|
gv.setDSOLocal(shouldAssumeDSOLocal(*this, gv));
|
|
}
|
|
|
|
void CIRGenModule::setDSOLocal(mlir::Operation *op) const {
|
|
if (auto globalValue = dyn_cast<cir::CIRGlobalValueInterface>(op))
|
|
setDSOLocal(globalValue);
|
|
}
|
|
|
|
void CIRGenModule::setGVProperties(mlir::Operation *op,
|
|
const NamedDecl *d) const {
|
|
assert(!cir::MissingFeatures::opGlobalDLLImportExport());
|
|
setGVPropertiesAux(op, d);
|
|
}
|
|
|
|
void CIRGenModule::setGVPropertiesAux(mlir::Operation *op,
|
|
const NamedDecl *d) const {
|
|
setGlobalVisibility(op, d);
|
|
setDSOLocal(op);
|
|
assert(!cir::MissingFeatures::opGlobalPartition());
|
|
}
|
|
|
|
void CIRGenModule::setFunctionAttributes(GlobalDecl globalDecl,
|
|
cir::FuncOp func,
|
|
bool isIncompleteFunction,
|
|
bool isThunk) {
|
|
// NOTE(cir): Original CodeGen checks if this is an intrinsic. In CIR we
|
|
// represent them in dedicated ops. The correct attributes are ensured during
|
|
// translation to LLVM. Thus, we don't need to check for them here.
|
|
|
|
assert(!cir::MissingFeatures::setFunctionAttributes());
|
|
assert(!cir::MissingFeatures::setTargetAttributes());
|
|
|
|
// TODO(cir): This needs a lot of work to better match CodeGen. That
|
|
// ultimately ends up in setGlobalVisibility, which already has the linkage of
|
|
// the LLVM GV (corresponding to our FuncOp) computed, so it doesn't have to
|
|
// recompute it here. This is a minimal fix for now.
|
|
if (!isLocalLinkage(getFunctionLinkage(globalDecl))) {
|
|
const Decl *decl = globalDecl.getDecl();
|
|
func.setGlobalVisibilityAttr(getGlobalVisibilityAttrFromDecl(decl));
|
|
}
|
|
}
|
|
|
|
cir::FuncOp CIRGenModule::getOrCreateCIRFunction(
|
|
StringRef mangledName, mlir::Type funcType, GlobalDecl gd, bool forVTable,
|
|
bool dontDefer, bool isThunk, ForDefinition_t isForDefinition,
|
|
mlir::ArrayAttr extraAttrs) {
|
|
const Decl *d = gd.getDecl();
|
|
|
|
if (isThunk)
|
|
errorNYI(d->getSourceRange(), "getOrCreateCIRFunction: thunk");
|
|
|
|
// In what follows, we continue past 'errorNYI' as if nothing happened because
|
|
// the rest of the implementation is better than doing nothing.
|
|
|
|
if (const auto *fd = cast_or_null<FunctionDecl>(d)) {
|
|
// For the device mark the function as one that should be emitted.
|
|
if (getLangOpts().OpenMPIsTargetDevice && fd->isDefined() && !dontDefer &&
|
|
!isForDefinition)
|
|
errorNYI(fd->getSourceRange(),
|
|
"getOrCreateCIRFunction: OpenMP target function");
|
|
|
|
// Any attempts to use a MultiVersion function should result in retrieving
|
|
// the iFunc instead. Name mangling will handle the rest of the changes.
|
|
if (fd->isMultiVersion())
|
|
errorNYI(fd->getSourceRange(), "getOrCreateCIRFunction: multi-version");
|
|
}
|
|
|
|
// Lookup the entry, lazily creating it if necessary.
|
|
mlir::Operation *entry = getGlobalValue(mangledName);
|
|
if (entry) {
|
|
assert(mlir::isa<cir::FuncOp>(entry));
|
|
|
|
assert(!cir::MissingFeatures::weakRefReference());
|
|
|
|
// Handle dropped DLL attributes.
|
|
if (d && !d->hasAttr<DLLImportAttr>() && !d->hasAttr<DLLExportAttr>()) {
|
|
assert(!cir::MissingFeatures::setDLLStorageClass());
|
|
setDSOLocal(entry);
|
|
}
|
|
|
|
// If there are two attempts to define the same mangled name, issue an
|
|
// error.
|
|
auto fn = cast<cir::FuncOp>(entry);
|
|
if (isForDefinition && fn && !fn.isDeclaration()) {
|
|
errorNYI(d->getSourceRange(), "Duplicate function definition");
|
|
}
|
|
if (fn && fn.getFunctionType() == funcType) {
|
|
return fn;
|
|
}
|
|
|
|
if (!isForDefinition) {
|
|
return fn;
|
|
}
|
|
|
|
// TODO(cir): classic codegen checks here if this is a llvm::GlobalAlias.
|
|
// How will we support this?
|
|
}
|
|
|
|
auto *funcDecl = llvm::cast_or_null<FunctionDecl>(gd.getDecl());
|
|
bool invalidLoc = !funcDecl ||
|
|
funcDecl->getSourceRange().getBegin().isInvalid() ||
|
|
funcDecl->getSourceRange().getEnd().isInvalid();
|
|
cir::FuncOp funcOp = createCIRFunction(
|
|
invalidLoc ? theModule->getLoc() : getLoc(funcDecl->getSourceRange()),
|
|
mangledName, mlir::cast<cir::FuncType>(funcType), funcDecl);
|
|
|
|
// If we already created a function with the same mangled name (but different
|
|
// type) before, take its name and add it to the list of functions to be
|
|
// replaced with F at the end of CodeGen.
|
|
//
|
|
// This happens if there is a prototype for a function (e.g. "int f()") and
|
|
// then a definition of a different type (e.g. "int f(int x)").
|
|
if (entry) {
|
|
|
|
// Fetch a generic symbol-defining operation and its uses.
|
|
auto symbolOp = mlir::cast<mlir::SymbolOpInterface>(entry);
|
|
|
|
// This might be an implementation of a function without a prototype, in
|
|
// which case, try to do special replacement of calls which match the new
|
|
// prototype. The really key thing here is that we also potentially drop
|
|
// arguments from the call site so as to make a direct call, which makes the
|
|
// inliner happier and suppresses a number of optimizer warnings (!) about
|
|
// dropping arguments.
|
|
if (symbolOp.getSymbolUses(symbolOp->getParentOp()))
|
|
replaceUsesOfNonProtoTypeWithRealFunction(entry, funcOp);
|
|
|
|
// Obliterate no-proto declaration.
|
|
entry->erase();
|
|
}
|
|
|
|
if (d)
|
|
setFunctionAttributes(gd, funcOp, /*isIncompleteFunction=*/false, isThunk);
|
|
|
|
// 'dontDefer' actually means don't move this to the deferredDeclsToEmit list.
|
|
if (dontDefer) {
|
|
// TODO(cir): This assertion will need an additional condition when we
|
|
// support incomplete functions.
|
|
assert(funcOp.getFunctionType() == funcType);
|
|
return funcOp;
|
|
}
|
|
|
|
// All MSVC dtors other than the base dtor are linkonce_odr and delegate to
|
|
// each other bottoming out wiht the base dtor. Therefore we emit non-base
|
|
// dtors on usage, even if there is no dtor definition in the TU.
|
|
if (isa_and_nonnull<CXXDestructorDecl>(d) &&
|
|
getCXXABI().useThunkForDtorVariant(cast<CXXDestructorDecl>(d),
|
|
gd.getDtorType()))
|
|
errorNYI(d->getSourceRange(), "getOrCreateCIRFunction: dtor");
|
|
|
|
// This is the first use or definition of a mangled name. If there is a
|
|
// deferred decl with this name, remember that we need to emit it at the end
|
|
// of the file.
|
|
auto ddi = deferredDecls.find(mangledName);
|
|
if (ddi != deferredDecls.end()) {
|
|
// Move the potentially referenced deferred decl to the
|
|
// DeferredDeclsToEmit list, and remove it from DeferredDecls (since we
|
|
// don't need it anymore).
|
|
addDeferredDeclToEmit(ddi->second);
|
|
deferredDecls.erase(ddi);
|
|
|
|
// Otherwise, there are cases we have to worry about where we're using a
|
|
// declaration for which we must emit a definition but where we might not
|
|
// find a top-level definition.
|
|
// - member functions defined inline in their classes
|
|
// - friend functions defined inline in some class
|
|
// - special member functions with implicit definitions
|
|
// If we ever change our AST traversal to walk into class methods, this
|
|
// will be unnecessary.
|
|
//
|
|
// We also don't emit a definition for a function if it's going to be an
|
|
// entry in a vtable, unless it's already marked as used.
|
|
} else if (getLangOpts().CPlusPlus && d) {
|
|
// Look for a declaration that's lexically in a record.
|
|
for (const auto *fd = cast<FunctionDecl>(d)->getMostRecentDecl(); fd;
|
|
fd = fd->getPreviousDecl()) {
|
|
if (isa<CXXRecordDecl>(fd->getLexicalDeclContext())) {
|
|
if (fd->doesThisDeclarationHaveABody()) {
|
|
addDeferredDeclToEmit(gd.getWithDecl(fd));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return funcOp;
|
|
}
|
|
|
|
cir::FuncOp
|
|
CIRGenModule::createCIRFunction(mlir::Location loc, StringRef name,
|
|
cir::FuncType funcType,
|
|
const clang::FunctionDecl *funcDecl) {
|
|
cir::FuncOp func;
|
|
{
|
|
mlir::OpBuilder::InsertionGuard guard(builder);
|
|
|
|
// Some global emissions are triggered while emitting a function, e.g.
|
|
// void s() { x.method() }
|
|
//
|
|
// Be sure to insert a new function before a current one.
|
|
CIRGenFunction *cgf = this->curCGF;
|
|
if (cgf)
|
|
builder.setInsertionPoint(cgf->curFn);
|
|
|
|
func = builder.create<cir::FuncOp>(loc, name, funcType);
|
|
|
|
assert(!cir::MissingFeatures::opFuncAstDeclAttr());
|
|
|
|
if (funcDecl && !funcDecl->hasPrototype())
|
|
func.setNoProto(true);
|
|
|
|
assert(func.isDeclaration() && "expected empty body");
|
|
|
|
// A declaration gets private visibility by default, but external linkage
|
|
// as the default linkage.
|
|
func.setLinkageAttr(cir::GlobalLinkageKindAttr::get(
|
|
&getMLIRContext(), cir::GlobalLinkageKind::ExternalLinkage));
|
|
mlir::SymbolTable::setSymbolVisibility(
|
|
func, mlir::SymbolTable::Visibility::Private);
|
|
|
|
assert(!cir::MissingFeatures::opFuncExtraAttrs());
|
|
|
|
if (!cgf)
|
|
theModule.push_back(func);
|
|
}
|
|
return func;
|
|
}
|
|
|
|
mlir::SymbolTable::Visibility
|
|
CIRGenModule::getMLIRVisibility(cir::GlobalOp op) {
|
|
// MLIR doesn't accept public symbols declarations (only
|
|
// definitions).
|
|
if (op.isDeclaration())
|
|
return mlir::SymbolTable::Visibility::Private;
|
|
return getMLIRVisibilityFromCIRLinkage(op.getLinkage());
|
|
}
|
|
|
|
mlir::SymbolTable::Visibility
|
|
CIRGenModule::getMLIRVisibilityFromCIRLinkage(cir::GlobalLinkageKind glk) {
|
|
switch (glk) {
|
|
case cir::GlobalLinkageKind::InternalLinkage:
|
|
case cir::GlobalLinkageKind::PrivateLinkage:
|
|
return mlir::SymbolTable::Visibility::Private;
|
|
case cir::GlobalLinkageKind::ExternalLinkage:
|
|
case cir::GlobalLinkageKind::ExternalWeakLinkage:
|
|
case cir::GlobalLinkageKind::LinkOnceODRLinkage:
|
|
case cir::GlobalLinkageKind::AvailableExternallyLinkage:
|
|
case cir::GlobalLinkageKind::CommonLinkage:
|
|
case cir::GlobalLinkageKind::WeakAnyLinkage:
|
|
case cir::GlobalLinkageKind::WeakODRLinkage:
|
|
return mlir::SymbolTable::Visibility::Public;
|
|
default: {
|
|
llvm::errs() << "visibility not implemented for '"
|
|
<< stringifyGlobalLinkageKind(glk) << "'\n";
|
|
assert(0 && "not implemented");
|
|
}
|
|
}
|
|
llvm_unreachable("linkage should be handled above!");
|
|
}
|
|
|
|
cir::VisibilityKind CIRGenModule::getGlobalVisibilityKindFromClangVisibility(
|
|
clang::VisibilityAttr::VisibilityType visibility) {
|
|
switch (visibility) {
|
|
case clang::VisibilityAttr::VisibilityType::Default:
|
|
return cir::VisibilityKind::Default;
|
|
case clang::VisibilityAttr::VisibilityType::Hidden:
|
|
return cir::VisibilityKind::Hidden;
|
|
case clang::VisibilityAttr::VisibilityType::Protected:
|
|
return cir::VisibilityKind::Protected;
|
|
}
|
|
llvm_unreachable("unexpected visibility value");
|
|
}
|
|
|
|
cir::VisibilityAttr
|
|
CIRGenModule::getGlobalVisibilityAttrFromDecl(const Decl *decl) {
|
|
const clang::VisibilityAttr *va = decl->getAttr<clang::VisibilityAttr>();
|
|
cir::VisibilityAttr cirVisibility =
|
|
cir::VisibilityAttr::get(&getMLIRContext());
|
|
if (va) {
|
|
cirVisibility = cir::VisibilityAttr::get(
|
|
&getMLIRContext(),
|
|
getGlobalVisibilityKindFromClangVisibility(va->getVisibility()));
|
|
}
|
|
return cirVisibility;
|
|
}
|
|
|
|
void CIRGenModule::release() {
|
|
emitDeferred();
|
|
applyReplacements();
|
|
|
|
theModule->setAttr(cir::CIRDialect::getModuleLevelAsmAttrName(),
|
|
builder.getArrayAttr(globalScopeAsm));
|
|
|
|
// There's a lot of code that is not implemented yet.
|
|
assert(!cir::MissingFeatures::cgmRelease());
|
|
}
|
|
|
|
void CIRGenModule::emitAliasForGlobal(StringRef mangledName,
|
|
mlir::Operation *op, GlobalDecl aliasGD,
|
|
cir::FuncOp aliasee,
|
|
cir::GlobalLinkageKind linkage) {
|
|
|
|
auto *aliasFD = dyn_cast<FunctionDecl>(aliasGD.getDecl());
|
|
assert(aliasFD && "expected FunctionDecl");
|
|
|
|
// The aliasee function type is different from the alias one, this difference
|
|
// is specific to CIR because in LLVM the ptr types are already erased at this
|
|
// point.
|
|
const CIRGenFunctionInfo &fnInfo =
|
|
getTypes().arrangeCXXStructorDeclaration(aliasGD);
|
|
cir::FuncType fnType = getTypes().getFunctionType(fnInfo);
|
|
|
|
cir::FuncOp alias =
|
|
createCIRFunction(getLoc(aliasGD.getDecl()->getSourceRange()),
|
|
mangledName, fnType, aliasFD);
|
|
alias.setAliasee(aliasee.getName());
|
|
alias.setLinkage(linkage);
|
|
// Declarations cannot have public MLIR visibility, just mark them private
|
|
// but this really should have no meaning since CIR should not be using
|
|
// this information to derive linkage information.
|
|
mlir::SymbolTable::setSymbolVisibility(
|
|
alias, mlir::SymbolTable::Visibility::Private);
|
|
|
|
// Alias constructors and destructors are always unnamed_addr.
|
|
assert(!cir::MissingFeatures::opGlobalUnnamedAddr());
|
|
|
|
// Switch any previous uses to the alias.
|
|
if (op) {
|
|
errorNYI(aliasFD->getSourceRange(), "emitAliasForGlobal: previous uses");
|
|
} else {
|
|
// Name already set by createCIRFunction
|
|
}
|
|
|
|
// Finally, set up the alias with its proper name and attributes.
|
|
setCommonAttributes(aliasGD, alias);
|
|
}
|
|
|
|
mlir::Type CIRGenModule::convertType(QualType type) {
|
|
return genTypes.convertType(type);
|
|
}
|
|
|
|
bool CIRGenModule::verifyModule() const {
|
|
// Verify the module after we have finished constructing it, this will
|
|
// check the structural properties of the IR and invoke any specific
|
|
// verifiers we have on the CIR operations.
|
|
return mlir::verify(theModule).succeeded();
|
|
}
|
|
|
|
// TODO(cir): this can be shared with LLVM codegen.
|
|
CharUnits CIRGenModule::computeNonVirtualBaseClassOffset(
|
|
const CXXRecordDecl *derivedClass,
|
|
llvm::iterator_range<CastExpr::path_const_iterator> path) {
|
|
CharUnits offset = CharUnits::Zero();
|
|
|
|
const ASTContext &astContext = getASTContext();
|
|
const CXXRecordDecl *rd = derivedClass;
|
|
|
|
for (const CXXBaseSpecifier *base : path) {
|
|
assert(!base->isVirtual() && "Should not see virtual bases here!");
|
|
|
|
// Get the layout.
|
|
const ASTRecordLayout &layout = astContext.getASTRecordLayout(rd);
|
|
|
|
const auto *baseDecl =
|
|
cast<CXXRecordDecl>(
|
|
base->getType()->castAs<clang::RecordType>()->getOriginalDecl())
|
|
->getDefinitionOrSelf();
|
|
|
|
// Add the offset.
|
|
offset += layout.getBaseClassOffset(baseDecl);
|
|
|
|
rd = baseDecl;
|
|
}
|
|
|
|
return offset;
|
|
}
|
|
|
|
DiagnosticBuilder CIRGenModule::errorNYI(SourceLocation loc,
|
|
llvm::StringRef feature) {
|
|
unsigned diagID = diags.getCustomDiagID(
|
|
DiagnosticsEngine::Error, "ClangIR code gen Not Yet Implemented: %0");
|
|
return diags.Report(loc, diagID) << feature;
|
|
}
|
|
|
|
DiagnosticBuilder CIRGenModule::errorNYI(SourceRange loc,
|
|
llvm::StringRef feature) {
|
|
return errorNYI(loc.getBegin(), feature) << loc;
|
|
}
|