================
@@ -219,6 +236,252 @@ void CIRGenFunction::emitVarDecl(const VarDecl &d) {
return emitAutoVarDecl(d);
}
+static std::string getStaticDeclName(CIRGenModule &cgm, const VarDecl &d) {
+ if (cgm.getLangOpts().CPlusPlus)
+ return cgm.getMangledName(&d).str();
+
+ // If this isn't C++, we don't need a mangled name, just a pretty one.
+ assert(!d.isExternallyVisible() && "name shouldn't matter");
+ std::string contextName;
+ const DeclContext *dc = d.getDeclContext();
+ if (auto *cd = dyn_cast<CapturedDecl>(dc))
+ dc = cast<DeclContext>(cd->getNonClosureContext());
+ if (const auto *fd = dyn_cast<FunctionDecl>(dc))
+ contextName = std::string(cgm.getMangledName(fd));
+ else if (isa<BlockDecl>(dc))
+ cgm.errorNYI(d.getSourceRange(), "block decl context for static var");
+ else if (isa<ObjCMethodDecl>(dc))
+ cgm.errorNYI(d.getSourceRange(), "ObjC decl context for static var");
+ else
+ cgm.errorNYI(d.getSourceRange(), "Unknown context for static var decl");
+
+ contextName += "." + d.getNameAsString();
+ return contextName;
+}
+
+// TODO(cir): LLVM uses a Constant base class. Maybe CIR could leverage an
+// interface for all constants?
+cir::GlobalOp
+CIRGenModule::getOrCreateStaticVarDecl(const VarDecl &d,
+ cir::GlobalLinkageKind linkage) {
+ // In general, we don't always emit static var decls once before we reference
+ // them. It is possible to reference them before emitting the function that
+ // contains them, and it is possible to emit the containing function multiple
+ // times.
+ if (cir::GlobalOp existingGV = getStaticLocalDeclAddress(&d))
+ return existingGV;
+
+ QualType ty = d.getType();
+ assert(ty->isConstantSizeType() && "VLAs can't be static");
+
+ // Use the label if the variable is renamed with the asm-label extension.
+ std::string name;
+ if (d.hasAttr<AsmLabelAttr>())
+ errorNYI(d.getSourceRange(), "getOrCreateStaticVarDecl: asm label");
+ else
+ name = getStaticDeclName(*this, d);
+
+ mlir::Type lty = getTypes().convertTypeForMem(ty);
+ assert(!cir::MissingFeatures::addressSpace());
+
+ // OpenCL variables in local address space and CUDA shared
+ // variables cannot have an initializer.
+ mlir::Attribute init = nullptr;
----------------
andykaylor wrote:
This was one of those "making it look like the code that is to come" things.
The incubator code looks like this:
```
mlir::Attribute Init = nullptr;
if (D.hasAttr<LoaderUninitializedAttr>())
llvm_unreachable("CUDA is NYI");
else if (Ty.getAddressSpace() != LangAS::opencl_local &&
!D.hasAttr<CUDASharedAttr>())
Init = builder.getZeroInitAttr(convertType(Ty));
```
And so there is a path where it's left as nullptr. That's shouldn't be too hard
to figure out later though.
https://github.com/llvm/llvm-project/pull/143980
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
