//===- 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) { // 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); 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()) { 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(d) || isa(d)) return getAddrOfCXXStructor(gd, /*FnInfo=*/nullptr, /*FnType=*/nullptr, /*DontDefer=*/false, isForDefinition); if (isa(d)) { const CIRGenFunctionInfo &fi = getTypes().arrangeCXXMethodDeclaration(cast(d)); cir::FuncType ty = getTypes().getFunctionType(fi); return getAddrOfFunction(gd, ty, /*ForVTable=*/false, /*DontDefer=*/false, isForDefinition); } if (isa(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(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(op)) globalValueOp = mlir::SymbolTable::lookupSymbolIn(getModule(), gv.getNameAttr()); if (auto cirGlobalValue = dyn_cast(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 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(gd.getDecl())) { emitGlobalOpenACCDecl(cd); return; } const auto *global = cast(gd.getDecl()); if (const auto *fd = dyn_cast(global)) { // Update deferred annotations with the latest declaration if the function // was already used or defined. if (fd->hasAttr()) 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(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(gd.getDecl()); const CIRGenFunctionInfo &fi = getTypes().arrangeGlobalDeclaration(gd); cir::FuncType funcType = getTypes().getFunctionType(fi); cir::FuncOp funcOp = dyn_cast_if_present(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()) errorNYI(funcDecl->getSourceRange(), "constructor attribute"); if (funcDecl->getAttr()) errorNYI(funcDecl->getSourceRange(), "destructor attribute"); if (funcDecl->getAttr()) 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(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(d)) setGVProperties(gv, dyn_cast(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() || 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(v)) errorNYI(d->getSourceRange(), "global with non-GlobalOp type"); entry = cast(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()) 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(getLoc(d->getSourceRange()), ptrTy, g.getSymName()); } void CIRGenModule::emitGlobalVarDefinition(const clang::VarDecl *vd, bool isTentative) { const QualType astTy = vd->getType(); 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 emitter; assert(!cir::MissingFeatures::cudaSupport()); if (vd->hasAttr()) { 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(!astTy->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(init)) { errorNYI(vd->getSourceRange(), "global initializer is a symbol reference"); return; } else { assert(mlir::isa(init) && "This should have a type"); auto typedInitAttr = mlir::cast(init); initType = typedInitAttr.getType(); } assert(!mlir::isa(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()) { 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(gd.getDecl()); if (const auto *fd = dyn_cast(decl)) { // TODO(CIR): Skip generation of CIR for functions with available_externally // linkage at -O0. if (const auto *method = dyn_cast(decl)) { // Make sure to emit the definition(s) before we emit the thunks. This is // necessary for the generation of certain thunks. if (isa(method) || isa(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(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()) return true; GVALinkage linkage; if (auto *vd = dyn_cast(&d)) linkage = cgm.getASTContext().GetGVALinkageForVariable(vd); else linkage = cgm.getASTContext().GetGVALinkageForFunction(cast(&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(op)) { globalOp.setComdat(true); } else { auto funcOp = cast(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 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(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(entry) && "expected function"); auto oldF = cast(entry); auto newF = dyn_cast(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(); } } } // 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()) && !vd->hasAttr()) 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()) 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() || vd->hasAttr() || vd->hasAttr() || vd->hasAttr()) 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()) 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()) return true; QualType varType = vd->getType(); if (astContext.isAlignmentRequired(varType)) return true; if (const auto *rt = varType->getAs()) { const RecordDecl *rd = rt->getDecl(); for (const FieldDecl *fd : rd->fields()) { if (fd->isBitField()) continue; if (fd->hasAttr()) 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()) { 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() ? 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(dd) && !isVarDeclStrongDefinition(astContext, *this, cast(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()) return cir::GlobalLinkageKind::WeakODRLinkage; // Otherwise, we have strong external linkage. assert(linkage == GVA_StrongExternal); return cir::GlobalLinkageKind::ExternalLinkage; } 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(gd.getDecl()); GVALinkage linkage = astContext.GetGVALinkageForFunction(d); if (const auto *dtor = dyn_cast(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(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(c); cir::GlobalOp gv = generateStringLiteral(loc, typedC, cir::GlobalLinkageKind::PrivateLinkage, *this, uniqueName, alignment); setDSOLocal(static_cast(gv)); assert(!cir::MissingFeatures::sanitizers()); return gv; } 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(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::CXXMethod: case Decl::Function: { auto *fd = cast(decl); // Consteval functions shouldn't be emitted. if (!fd->isConsteval()) emitGlobal(fd); break; } case Decl::Var: { auto *vd = cast(decl); emitGlobal(vd); break; } case Decl::OpenACCRoutine: emitGlobalOpenACCDecl(cast(decl)); break; case Decl::OpenACCDeclare: emitGlobalOpenACCDecl(cast(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::UsingShadow: case Decl::Empty: break; case Decl::CXXConstructor: getCXXABI().emitCXXConstructors(cast(decl)); break; case Decl::CXXDestructor: getCXXABI().emitCXXDestructors(cast(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; } } void CIRGenModule::setInitializer(cir::GlobalOp &op, mlir::Attribute value) { // Recompute visibility when updating initializer. op.setInitialValueAttr(value); assert(!cir::MissingFeatures::opGlobalVisibility()); } std::pair CIRGenModule::getAddrAndTypeOfCXXStructor( GlobalDecl gd, const CIRGenFunctionInfo *fnInfo, cir::FuncType fnType, bool dontDefer, ForDefinition_t isForDefinition) { auto *md = cast(gd.getDecl()); if (isa(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(gd.getDecl())->isConsteval() && "consteval function should never be emitted"); if (!funcType) { const auto *fd = cast(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(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(nd); if (fd && fd->getType()->castAs()->getCallConv() == CC_X86RegCall) { cgm.errorNYI(nd->getSourceRange(), "getMangledName: X86RegCall"); } else if (fd && fd->hasAttr() && 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(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(canonicalGd.getDecl())) { if (!getTarget().getCXXABI().hasConstructorVariants()) { errorNYI(cd->getSourceRange(), "getMangledName: C++ constructor without variants"); return cast(gd.getDecl())->getIdentifier()->getName(); } } // Keep the first result in the case of a mangling collision. const auto *nd = cast(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(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(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 activeAttr = OMPDeclareTargetDeclAttr::getActiveAttr(global); if (!activeAttr || (*activeAttr)->getLevel() != (unsigned)-1) return false; } const auto *fd = dyn_cast(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() && !fd->isMultiVersion()) return false; if (langOpts.SYCLIsDevice) { errorNYI(fd->getSourceRange(), "mayBeEmittedEagerly: SYCL"); return false; } } const auto *vd = dyn_cast(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(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.isWindowsGNUEnvironment()) { // In MinGW, 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(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(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(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(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(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) { if (!isa(entry)) errorNYI(d->getSourceRange(), "getOrCreateCIRFunction: non-FuncOp"); assert(!cir::MissingFeatures::weakRefReference()); // Handle dropped DLL attributes. if (d && !d->hasAttr() && !d->hasAttr()) { assert(!cir::MissingFeatures::setDLLStorageClass()); setDSOLocal(entry); } // If there are two attempts to define the same mangled name, issue an // error. auto fn = cast(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(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(funcType), funcDecl); 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(d) && getCXXABI().useThunkForDtorVariant(cast(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(d)->getMostRecentDecl(); fd; fd = fd->getPreviousDecl()) { if (isa(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(loc, name, funcType); assert(!cir::MissingFeatures::opFuncAstDeclAttr()); assert(!cir::MissingFeatures::opFuncNoProto()); 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::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(); cir::VisibilityAttr cirVisibility = cir::VisibilityAttr::get(&getMLIRContext()); if (va) { cirVisibility = cir::VisibilityAttr::get( &getMLIRContext(), getGlobalVisibilityKindFromClangVisibility(va->getVisibility())); } return cirVisibility; } void CIRGenModule::release() { emitDeferred(); applyReplacements(); // 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(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 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( base->getType()->castAs()->getDecl()); // 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; }