[llvm] Add support for DW_TAG_immutable_type

[ljmf00]

Summary

Added documentation about DW_TAG_immutable_type too.

[ljmf00]

I still need to add tests

[probinson]

Typically I've done "support" for a tag or other DWARF feature in several phases, each usually (not necessarily) with its own patch. Each phase builds on the previous one, which is the project's preferred incremental-development model.

• First, do enough so that llvm-dwarfdump can correctly handle an object file with a DW_TAG_immutable_type in it; this generally means tweaking lib/DebugInfo/DWARF a little bit, as I see you have done. The test can be an assembler file with the raw bytes listed; there are many examples of this.
• Next, make it so textual IR can describe an immutable type, which can be emitted into an object file. The IR part might involve round-tripping through textual and bitcode formats to show that all works. For the object-file part you use llvm-dwarfdump, because your previous work verified that llvm-dwarfdump handles the tag correctly.
• Next, if you need to fiddle with DIBuilder to get the IR API to handle immutable types, you do that, probably with a unittest (not a Clang test, because LLVM has other frontend clients and LLVM testing should not depend on any of them).
• Finally, if this is a C/C++ language feature, you plumb it into Clang to emit the tag when appropriate, with a test that uses -emit-llvm and verify that the IR comes out right. I'm not aware that "immutable" is a C/C++ feature, but I find it hard to keep up with the C++ standard.

If the whole thing is trivial enough--which it might be, because this is a type qualifier like many others--you can do multiple phases in one patch, but we still want to see that each step has the proper testing.

[ljmf00]

In D113633#3127708, @probinson wrote:

Typically I've done "support" for a tag or other DWARF feature in several phases, each usually (not necessarily) with its own patch. Each phase builds on the previous one, which is the project's preferred incremental-development model.

• First, do enough so that llvm-dwarfdump can correctly handle an object file with a DW_TAG_immutable_type in it; this generally means tweaking lib/DebugInfo/DWARF a little bit, as I see you have done. The test can be an assembler file with the raw bytes listed; there are many examples of this.
• Next, make it so textual IR can describe an immutable type, which can be emitted into an object file. The IR part might involve round-tripping through textual and bitcode formats to show that all works. For the object-file part you use llvm-dwarfdump, because your previous work verified that llvm-dwarfdump handles the tag correctly.
• Next, if you need to fiddle with DIBuilder to get the IR API to handle immutable types, you do that, probably with a unittest (not a Clang test, because LLVM has other frontend clients and LLVM testing should not depend on any of them).
• Finally, if this is a C/C++ language feature, you plumb it into Clang to emit the tag when appropriate, with a test that uses -emit-llvm and verify that the IR comes out right. I'm not aware that "immutable" is a C/C++ feature, but I find it hard to keep up with the C++ standard.

If the whole thing is trivial enough--which it might be, because this is a type qualifier like many others--you can do multiple phases in one patch, but we still want to see that each step has the proper testing.

I did separate patches since they are independent of each other. As a new LLVM contributor, there are some things I miss, and I appreciate this input!

One of the rationales to do this was: since I've seen separate people working in LLVM core and LLDB I decided to separate documentation, and those pieces apart. I thought this could be beneficial for separate reviewers to analyze the change "in the lldb part", "in the llvm core part" and not as a whole. Plus, I noticed that different people get pinged depending on the patch and I assume it has something to do with the patch prefix.

[ljmf00]

Also, take the example of https://reviews.llvm.org/D113634 , which may be split into two patches for further discussion. Anyway, I tend to agree with you, I can join everything together in D113634.

[probinson]

In D113633#3127799, @ljmf00 wrote:

Also, take the example of https://reviews.llvm.org/D113634 , which may be split into two patches for further discussion. Anyway, I tend to agree with you, I can join everything together in D113634.

Usually (not always, but usually) related patches are split by subproject. So, lldb changes go in one patch, llvm in another patch, clang in another patch. Exceptions occur when patches are very closely related or actually interdependent. I don't think adding immutable_type falls into that category. So, please keep the lldb and llvm patches separate.

[ljmf00]

Added tests and squashed documentation as requested.

[probinson]

Code looks quite reasonable; the test needs a little cleanup.

llvm/test/DebugInfo/dwarfdump-immutable.ll

3

I believe you can remove the REQUIRES, explicit triple on the llc command, and the target triple IR clause, to allow this to work generically; there doesn't really seem to be anything X86-specific here. You'll want to use %llc_dwarf instead of llc as the command, which will insert an appropriate triple for hosts that don't implicitly use DWARF. See other examples of this in the same test directory.

9

This should be just CHECK: not CHECK-LABEL:.

[ljmf00]

llvm/test/DebugInfo/dwarfdump-immutable.ll

3

Done

9

Done

[probinson]

LGTM

llvm/docs/LangRef.rst

.. code-block:: text
   DW_TAG_typedef            = 22
   DW_TAG_inheritance        = 28
   DW_TAG_ptr_to_member_type = 31
   DW_TAG_const_type         = 38
   DW_TAG_friend             = 42
   DW_TAG_volatile_type      = 53
   DW_TAG_restrict_type      = 55
   DW_TAG_atomic_type        = 71
+  DW_TAG_immutable_type     = 75
 
 .. _DIDerivedTypeMember:
 
 ``DW_TAG_member`` is used to define a member of a :ref:`composite type
 <DICompositeType>`. The type of the member is the ``baseType:``. The
 ``offset:`` is the member's bit offset.  If the composite type has an ODR
 ``identifier:`` and does not set ``flags: DIFwdDecl``, then the member is
 uniqued based only on its ``name:`` and ``scope:``.
 
 ``DW_TAG_inheritance`` and ``DW_TAG_friend`` are used in the ``elements:``
 field of :ref:`composite types <DICompositeType>` to describe parents and
 friends.
 
 ``DW_TAG_typedef`` is used to provide a name for the ``baseType:``.
 
 ``DW_TAG_pointer_type``, ``DW_TAG_reference_type``, ``DW_TAG_const_type``,
-``DW_TAG_volatile_type``, ``DW_TAG_restrict_type`` and ``DW_TAG_atomic_type``
-are used to qualify the ``baseType:``.
+``DW_TAG_volatile_type``, ``DW_TAG_restrict_type``, ``DW_TAG_atomic_type`` and
+``DW_TAG_immutable_type`` are used to qualify the ``baseType:``.
 
 Note that the ``void *`` type is expressed as a type derived from NULL.
 
 .. _DICompositeType:
 
 DICompositeType
 """""""""""""""
 

llvm/docs/SourceLevelDebugging.rst

 * DW_TAG_subroutine_type
 * DW_TAG_typedef
 * DW_TAG_union_type
 * DW_TAG_ptr_to_member_type
 * DW_TAG_set_type
 * DW_TAG_subrange_type
 * DW_TAG_base_type
 * DW_TAG_const_type
+* DW_TAG_immutable_type
 * DW_TAG_file_type
 * DW_TAG_namelist
 * DW_TAG_packed_type
 * DW_TAG_volatile_type
 * DW_TAG_restrict_type
 * DW_TAG_atomic_type
 * DW_TAG_interface_type
 * DW_TAG_unspecified_type

llvm/lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp

uint64_t DebugHandlerBase::getBaseTypeSize(const DIType *Ty) {
   const DIDerivedType *DDTy = dyn_cast<DIDerivedType>(Ty);
   if (!DDTy)
     return Ty->getSizeInBits();
 
   unsigned Tag = DDTy->getTag();
 
   if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
       Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
-      Tag != dwarf::DW_TAG_restrict_type && Tag != dwarf::DW_TAG_atomic_type)
+      Tag != dwarf::DW_TAG_restrict_type && Tag != dwarf::DW_TAG_atomic_type &&
+      Tag != dwarf::DW_TAG_immutable_type)
     return DDTy->getSizeInBits();
 
   DIType *BaseType = DDTy->getBaseType();
 
   if (!BaseType)
     return 0;
 
   // If this is a derived type, go ahead and get the base type, unless it's a
if (auto *DTy = dyn_cast<DIDerivedType>(Ty)) {
     // dbg.values.
     if (T == dwarf::DW_TAG_pointer_type ||
         T == dwarf::DW_TAG_ptr_to_member_type ||
         T == dwarf::DW_TAG_reference_type ||
         T == dwarf::DW_TAG_rvalue_reference_type)
       return true;
     assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type ||
            T == dwarf::DW_TAG_volatile_type ||
-           T == dwarf::DW_TAG_restrict_type || T == dwarf::DW_TAG_atomic_type);
+           T == dwarf::DW_TAG_restrict_type || T == dwarf::DW_TAG_atomic_type ||
+           T == dwarf::DW_TAG_immutable_type);
     assert(DTy->getBaseType() && "Expected valid base type");
     return isUnsignedDIType(DTy->getBaseType());
   }
 
   auto *BTy = cast<DIBasicType>(Ty);
   unsigned Encoding = BTy->getEncoding();
   assert((Encoding == dwarf::DW_ATE_unsigned ||
           Encoding == dwarf::DW_ATE_unsigned_char ||

llvm/lib/DWARFLinker/DWARFLinker.cpp

static bool isTypeTag(uint16_t Tag) {
   case dwarf::DW_TAG_namelist:
   case dwarf::DW_TAG_packed_type:
   case dwarf::DW_TAG_volatile_type:
   case dwarf::DW_TAG_restrict_type:
   case dwarf::DW_TAG_atomic_type:
   case dwarf::DW_TAG_interface_type:
   case dwarf::DW_TAG_unspecified_type:
   case dwarf::DW_TAG_shared_type:
+  case dwarf::DW_TAG_immutable_type:
     return true;
   default:
     break;
   }
   return false;
 }
 
 AddressesMap::~AddressesMap() {}

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

case DW_TAG_rvalue_reference_type:
     return PointerSize;
   case DW_TAG_ptr_to_member_type: {
     if (DWARFDie BaseType = Type.getAttributeValueAsReferencedDie(DW_AT_type))
       if (BaseType.getTag() == DW_TAG_subroutine_type)
         return 2 * PointerSize;
     return PointerSize;
   }
   case DW_TAG_const_type:
+  case DW_TAG_immutable_type:
   case DW_TAG_volatile_type:
   case DW_TAG_restrict_type:
   case DW_TAG_typedef: {
     if (DWARFDie BaseType = Type.getAttributeValueAsReferencedDie(DW_AT_type))
       return getTypeSize(BaseType, PointerSize);
     break;
   }
   case DW_TAG_array_type: {

llvm/lib/IR/Verifier.cpp

void Verifier::visitDIDerivedType(const DIDerivedType &N) {
   visitDIScope(N);
 
   AssertDI(N.getTag() == dwarf::DW_TAG_typedef ||
                N.getTag() == dwarf::DW_TAG_pointer_type ||
                N.getTag() == dwarf::DW_TAG_ptr_to_member_type ||
                N.getTag() == dwarf::DW_TAG_reference_type ||
                N.getTag() == dwarf::DW_TAG_rvalue_reference_type ||
                N.getTag() == dwarf::DW_TAG_const_type ||
+               N.getTag() == dwarf::DW_TAG_immutable_type ||
                N.getTag() == dwarf::DW_TAG_volatile_type ||
                N.getTag() == dwarf::DW_TAG_restrict_type ||
                N.getTag() == dwarf::DW_TAG_atomic_type ||
                N.getTag() == dwarf::DW_TAG_member ||
                N.getTag() == dwarf::DW_TAG_inheritance ||
                N.getTag() == dwarf::DW_TAG_friend ||
                N.getTag() == dwarf::DW_TAG_set_type,
            "invalid tag", &N);

llvm/test/DebugInfo/dwarfdump-immutable.ll

+;; This test checks whether DWARF tag DW_TAG_immutable_type
+;; is accepted and processed.
+; REQUIRES: x86_64-linux
+
+; RUN: llc -mtriple=x86_64-pc-linux-gnu %s -filetype=obj -o - | llvm-dwarfdump - | FileCheck %s
+
+;; Test whether DW_TAG_immutable_type is accepted.
+
+; CHECK-LABEL: DW_TAG_immutable_type
+
+; ModuleID = 'immutable.d'
+source_filename = "immutable.d"
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-pc-linux-gnu"
+
+@_D9immutable1aya = constant i8 97, align 1, !dbg !0 ; [#uses = 0]
+
+!llvm.module.flags = !{!5}
+!llvm.dbg.cu = !{!6}
+!llvm.ident = !{!13}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "a", linkageName: "_D9immutable1aya", scope: !2, file: !3, line: 1, type: !4, isLocal: false, isDefinition: true)
+!2 = !DIModule(scope: !3, name: "immutable")
+!3 = !DIFile(filename: "immutable.d", directory: "/home/luis/Temp")
+!4 = !DIDerivedType(tag: DW_TAG_immutable_type, baseType: !14)
+!5 = !{i32 2, !"Debug Info Version", i32 3}
+!6 = distinct !DICompileUnit(language: DW_LANG_D, file: !3, producer: "LDC 1.28.0 (LLVM 13.0.0)", isOptimized: false, runtimeVersion: 1, emissionKind: FullDebug, enums: !7, globals: !8, imports: !9)
+!7 = !{}
+!8 = !{!0}
+!9 = !{!10}
+!10 = !DIImportedEntity(tag: DW_TAG_imported_module, scope: !2, entity: !11, file: !3)
+!11 = !DIModule(scope: !12, name: "object")
+!12 = !DIFile(filename: "usr/include/dlang/ldc/object.d", directory: "/")
+!13 = !{!"ldc version 1.28.0"}
+!14 = !DIBasicType(name: "char", size: 8, encoding: DW_ATE_UTF)