Add LLVM IR debug info support for Fortran COMMON blocks
COMMON blocks are a feature of Fortran that has no direct analog in C languages, but they are similar to data sections in assembly language programming. A COMMON block is a named area of memory that holds a collection of variables. Fortran subprograms may map the COMMON block memory area to their own, possibly distinct, non-empty list of variables. A Fortran COMMON block might look like the following example.
COMMON /ALPHA/ I, J
For this construct, the compiler generates a new scope-like DI construct (!DICommonBlock) into which variables (see I, J above) can be placed. As the common block implies a range of storage with global lifetime, the !DICommonBlock refers to a !DIGlobalVariable. The Fortran variable that comprise the COMMON block are also linked via metadata to offsets within the global variable that stands for the entire common block.
@alpha_ = common global %alphabytes_ zeroinitializer, align 64, !dbg !27, !dbg !30, !dbg !33
!14 = distinct !DISubprogram(…)
!20 = distinct !DICommonBlock(scope: !14, declaration: !25, name: "alpha")
!25 = distinct !DIGlobalVariable(scope: !20, name: "common alpha", type: !24)
!27 = !DIGlobalVariableExpression(var: !25, expr: !DIExpression())
!29 = distinct !DIGlobalVariable(scope: !20, name: "i", file: !3, type: !28)
!30 = !DIGlobalVariableExpression(var: !29, expr: !DIExpression())
!31 = distinct !DIGlobalVariable(scope: !20, name: "j", file: !3, type: !28)
!32 = !DIExpression(DW_OP_plus_uconst, 4)
!33 = !DIGlobalVariableExpression(var: !31, expr: !32)
The DWARF generated for this is as follows.
DW_TAG_common_block:
DW_AT_name: alpha
DW_AT_location: @alpha_+0
DW_TAG_variable:
DW_AT_name: common alpha
DW_AT_type: array of 8 bytes
DW_AT_location: @alpha_+0
DW_TAG_variable:
DW_AT_name: i
DW_AT_type: integer*4
DW_AT_location: @Alpha+0
DW_TAG_variable:
DW_AT_name: j
DW_AT_type: integer*4
DW_AT_location: @Alpha+4
Patch by Eric Schweitz!
Differential Revision: https://reviews.llvm.org/D54327
llvm-svn: 357934
diff --git a/llvm/lib/IR/AsmWriter.cpp b/llvm/lib/IR/AsmWriter.cpp
index ad6c2c8..376262b 100644
--- a/llvm/lib/IR/AsmWriter.cpp
+++ b/llvm/lib/IR/AsmWriter.cpp
@@ -2001,6 +2001,19 @@
Out << ")";
}
+static void writeDICommonBlock(raw_ostream &Out, const DICommonBlock *N,
+ TypePrinting *TypePrinter, SlotTracker *Machine,
+ const Module *Context) {
+ Out << "!DICommonBlock(";
+ MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
+ Printer.printMetadata("scope", N->getRawScope(), false);
+ Printer.printMetadata("declaration", N->getRawDecl(), false);
+ Printer.printString("name", N->getName());
+ Printer.printMetadata("file", N->getRawFile());
+ Printer.printInt("line", N->getLineNo());
+ Out << ")";
+}
+
static void writeDIMacro(raw_ostream &Out, const DIMacro *N,
TypePrinting *TypePrinter, SlotTracker *Machine,
const Module *Context) {
diff --git a/llvm/lib/IR/DIBuilder.cpp b/llvm/lib/IR/DIBuilder.cpp
index c248740..0cd3370 100644
--- a/llvm/lib/IR/DIBuilder.cpp
+++ b/llvm/lib/IR/DIBuilder.cpp
@@ -805,6 +805,13 @@
return SP;
}
+DICommonBlock *DIBuilder::createCommonBlock(
+ DIScope *Scope, DIGlobalVariable *Decl, StringRef Name, DIFile *File,
+ unsigned LineNo) {
+ return DICommonBlock::get(
+ VMContext, Scope, Decl, Name, File, LineNo);
+}
+
DINamespace *DIBuilder::createNameSpace(DIScope *Scope, StringRef Name,
bool ExportSymbols) {
diff --git a/llvm/lib/IR/DebugInfoMetadata.cpp b/llvm/lib/IR/DebugInfoMetadata.cpp
index 0ae408a..7158e57 100644
--- a/llvm/lib/IR/DebugInfoMetadata.cpp
+++ b/llvm/lib/IR/DebugInfoMetadata.cpp
@@ -222,6 +222,9 @@
if (auto *NS = dyn_cast<DINamespace>(this))
return NS->getScope();
+ if (auto *CB = dyn_cast<DICommonBlock>(this))
+ return CB->getScope();
+
if (auto *M = dyn_cast<DIModule>(this))
return M->getScope();
@@ -237,6 +240,8 @@
return SP->getName();
if (auto *NS = dyn_cast<DINamespace>(this))
return NS->getName();
+ if (auto *CB = dyn_cast<DICommonBlock>(this))
+ return CB->getName();
if (auto *M = dyn_cast<DIModule>(this))
return M->getName();
assert((isa<DILexicalBlockBase>(this) || isa<DIFile>(this) ||
@@ -694,6 +699,17 @@
DEFINE_GETIMPL_STORE(DINamespace, (ExportSymbols), Ops);
}
+DICommonBlock *DICommonBlock::getImpl(LLVMContext &Context, Metadata *Scope,
+ Metadata *Decl, MDString *Name,
+ Metadata *File, unsigned LineNo,
+ StorageType Storage, bool ShouldCreate) {
+ assert(isCanonical(Name) && "Expected canonical MDString");
+ DEFINE_GETIMPL_LOOKUP(DICommonBlock, (Scope, Decl, Name, File, LineNo));
+ // The nullptr is for DIScope's File operand. This should be refactored.
+ Metadata *Ops[] = {Scope, Decl, Name, File};
+ DEFINE_GETIMPL_STORE(DICommonBlock, (LineNo), Ops);
+}
+
DIModule *DIModule::getImpl(LLVMContext &Context, Metadata *Scope,
MDString *Name, MDString *ConfigurationMacros,
MDString *IncludePath, MDString *ISysRoot,
diff --git a/llvm/lib/IR/LLVMContextImpl.h b/llvm/lib/IR/LLVMContextImpl.h
index 42dd471..aaa765b 100644
--- a/llvm/lib/IR/LLVMContextImpl.h
+++ b/llvm/lib/IR/LLVMContextImpl.h
@@ -789,6 +789,31 @@
}
};
+template <> struct MDNodeKeyImpl<DICommonBlock> {
+ Metadata *Scope;
+ Metadata *Decl;
+ MDString *Name;
+ Metadata *File;
+ unsigned LineNo;
+
+ MDNodeKeyImpl(Metadata *Scope, Metadata *Decl, MDString *Name,
+ Metadata *File, unsigned LineNo)
+ : Scope(Scope), Decl(Decl), Name(Name), File(File), LineNo(LineNo) {}
+ MDNodeKeyImpl(const DICommonBlock *N)
+ : Scope(N->getRawScope()), Decl(N->getRawDecl()), Name(N->getRawName()),
+ File(N->getRawFile()), LineNo(N->getLineNo()) {}
+
+ bool isKeyOf(const DICommonBlock *RHS) const {
+ return Scope == RHS->getRawScope() && Decl == RHS->getRawDecl() &&
+ Name == RHS->getRawName() && File == RHS->getRawFile() &&
+ LineNo == RHS->getLineNo();
+ }
+
+ unsigned getHashValue() const {
+ return hash_combine(Scope, Decl, Name, File, LineNo);
+ }
+};
+
template <> struct MDNodeKeyImpl<DIModule> {
Metadata *Scope;
MDString *Name;
diff --git a/llvm/lib/IR/Verifier.cpp b/llvm/lib/IR/Verifier.cpp
index c371087..837f2d0 100644
--- a/llvm/lib/IR/Verifier.cpp
+++ b/llvm/lib/IR/Verifier.cpp
@@ -1156,6 +1156,14 @@
visitDILexicalBlockBase(N);
}
+void Verifier::visitDICommonBlock(const DICommonBlock &N) {
+ AssertDI(N.getTag() == dwarf::DW_TAG_common_block, "invalid tag", &N);
+ if (auto *S = N.getRawScope())
+ AssertDI(isa<DIScope>(S), "invalid scope ref", &N, S);
+ if (auto *S = N.getRawDecl())
+ AssertDI(isa<DIGlobalVariable>(S), "invalid declaration", &N, S);
+}
+
void Verifier::visitDINamespace(const DINamespace &N) {
AssertDI(N.getTag() == dwarf::DW_TAG_namespace, "invalid tag", &N);
if (auto *S = N.getRawScope())
@@ -1224,7 +1232,6 @@
visitDIVariable(N);
AssertDI(N.getTag() == dwarf::DW_TAG_variable, "invalid tag", &N);
- AssertDI(!N.getName().empty(), "missing global variable name", &N);
AssertDI(isType(N.getRawType()), "invalid type ref", &N, N.getRawType());
AssertDI(N.getType(), "missing global variable type", &N);
if (auto *Member = N.getRawStaticDataMemberDeclaration()) {