[RISCV] Support RISC-V ELF attribute section in llvm-readobj

[HsiangKai]

Summary

Enable llvm-readobj to handle RISC-V ELF attribute section.

[HsiangKai]

This patch is depended on D74023.

[MaskRay]

llvm/test/tools/llvm-readobj/ELF/RISCV/unknown-arch-attr.test

44 ↗

(On Diff #249023)

unittests/Support/RISCVAttributeParser.cpp is more suitable for such tests. See unittests/Support/ARMAttributeParser.cpp for examples.

[HsiangKai]

llvm/test/tools/llvm-readobj/ELF/RISCV/unknown-arch-attr.test

44 ↗

(On Diff #249023)

In current implementation, it will ignore unrecognized extensions. It intends to skip 'x1p0' and recognizes 'm2p0' and decodes mul instruction correctly. So, I think it is appropriate to create this test case.

[jhenderson]

llvm/test/MC/RISCV/attribute-with-option.s

2

It's not clear what this comment is trying to say. Could you turn it into a complete sentence please, describing what the test is testing.

8

'##'

[jhenderson]

llvm/test/tools/llvm-readobj/ELF/RISCV/attribute.s

2

to decode -> can decode

I think the canoncial name is "RISC-V", so you should use that in comments instead of "RISCV".

llvm/test/tools/llvm-readobj/ELF/RISCV/unknown-arch-attr.test

7 ↗

(On Diff #249023)

Is this test an llvm-objdump or llvm-readobj test? It looks to me like this test is testing llvm-objdump primarily, in which case it should be in the llvm-objdump directory, and maybe belongs in a separate change?

38–39 ↗

(On Diff #249023)

'##'

Same below.

llvm/tools/llvm-readobj/ELFDumper.cpp

2709

Is there a test case for this line?

2709

Is there a test case for this line?

2740

This is an existing mistake in the ARM version, but we shouldn't replicate it (and perhaps you could fix it separately). Unless E is going to be a duplicate of an already-reported error, this should report the error, probably as a warning, as there's no particular reason to terminate the program.

[HsiangKai]

llvm/tools/llvm-readobj/ELFDumper.cpp

2709

No, it is not related to this patch. Originally, printAttributes() is only implemented for ELFDumper<ELF32LE>. So, I check Obj->isLE() to keep original logic. In this way, it does not change the functionality of original version. So, I did not add a test case for it.

2709

No, it is not related to this patch.

2740

We could fix it separately.

[jhenderson]

llvm/test/MC/RISCV/attribute-with-option.s

2

When a user specifies an architecture extension which conflicts with an arhitecture attribute, we use the architecture attribute instead of the command line option.

5

specify the "e" extension

6

arch -> architecture
specify -> specifying
So, we -> This means we

13

RV32E. x16 -> RV32E, because x16

14

assemble. So, it -> assemble, since it

17

Check that the architecture attribute is not overridden by the command line option.

llvm/tools/llvm-readobj/ELFDumper.cpp

2709

The !Obj->isLE() line is new, so I think we need a test case that exercises this line as part of this change. You may be adding it to preserve existing behaviour, in which case, consider adding a test for it that in a prerequisite patch, to show that there is no behaviour change.

2709

Yes it is. The behaviour has gone from "not EM_ARM" to "not EM_ARM and not EM_RISCV", which means the code here is now exercised differently. Again, you could add a prerequisite test that shows that non-ARM architectures hit this. Then, in this patch, you would remove the EM_RISCV case.

2740

If you want to fix the ARM case separately, that's fine, but we shouldn't introduce the same mistake with new code for RISC-V.

[HsiangKai]

• Print out error messages if parsing attribute section error.
• Add more tests for invalid values in attribute section.
• Refine comments.

[HsiangKai]

llvm/tools/llvm-readobj/ELFDumper.cpp

2709

I add a test, validate-attr-section.test, for it.

2740

Print error messages out and add test cases for it.

[HsiangKai]

llvm/tools/llvm-readobj/ELFDumper.cpp

2709

I found printAttributes only called under EM_ARM and EM_RISCV. I add an assertion in printAttributes to ensure it.

[jhenderson]

llvm/test/MC/RISCV/attribute-with-option.s

7

Sorry, missed one bit in my last comment: "to specifying" -> "to specify".

18

overrided -> overridden

llvm/test/tools/llvm-readobj/ELF/RISCV/invalid-attr-size.test

6 ↗

(On Diff #251292)

Here and in the other tests, I'd add the full context for this message, i.e. something like {{.*}}.o: error: invalid subsection length (or whatever it is).

llvm/test/tools/llvm-readobj/ELF/RISCV/invalid-attr-subsection-size.test

1 ↗

(On Diff #251292)

It's entirely up to you, but you might want to fold all these "invalid-attr" tests into a single test file, with lots of yaml docs. I'm happy either way.

I am a bit confused by "invalid-attr-size.test" and "invalid-attr-subsection-size.test" given that the former appears to emit an error to do with the subsection size, whilst the latter is an error to do with the attribute size itself. Did you switch them around by accident?

llvm/test/tools/llvm-readobj/ELF/RISCV/invalid-attr-vendor.test

6 ↗

(On Diff #251292)

Probably should be "vendor name" without the hyphen (unless it is called "vendor-name" in the section specification).

llvm/test/tools/llvm-readobj/ELF/RISCV/validate-attr-section.test

2

"attribute section printing"

llvm/tools/llvm-readobj/ELFDumper.cpp

2734–2735

Can we remove this TODO (or at least part of it)?

[jhenderson]

Latest veresion basically looks fine. One suggestion and one question remaining from me.

llvm/test/tools/llvm-readobj/ELF/RISCV/invalid-attr-section-size.test

7

If you want to be more precise with your check (I don't think it matters too much, but it might be good), you can use something like FileCheck -DFILE=%t and change the pattern here to error: '[[FILE]].{{64|32]}.o':.

Same would apply in other tests.

19

Is the size 32-bits even for ELF64?

[HsiangKai]

llvm/test/tools/llvm-readobj/ELF/RISCV/invalid-attr-section-size.test

19

Yes, it is a 4-byte unsigned integer according to https://developer.arm.com/docs/ihi0044/h/elf-for-the-arm-architecture-abi-2019q1-documentation.

[jhenderson]

LGTM. Please wait for @MaskRay to approve too, since I don't know very much about the details here.

[MaskRay]

llvm/lib/Support/ELFAttributeParser.cpp

132

I use vendor-name because

<format-version>
[ <section-length> "vendor-name"
      [ <file-tag> <size> <attribute>*
      | <section-tag> <size> <section-number>* 0 <attribute>*
      | <symbol-tag> <size> <symbol-number>* 0 <attribute>*
      ]+
]*

I hope this change can be dropped.

150

subsection is not very appropriate. The original attribute seems to capture the collection (file/section/symbol) better.

220

subsection->section is fine, but length->size is not appropriate.

[MaskRay]

Consider grouping some llvm-readobj/ELF/RISCV/invalid-*.test tests together. We can make Content a template.

--- !ELF
FileHeader:
  Class:   ELFCLASS[[BITS]]
  Data:    ELFDATA2LSB
  Type:    ET_REL
  Machine: EM_RISCV
Sections:
  - Name:    .riscv.attributes
    Type:    SHT_RISCV_ATTRIBUTES
    Content: [[CONTENT]]

Actually, if we decide to use llvm/unittests a canonical place to test attributes, we should delete most duplicate tests in test/llvm-readobj/ELF/RISCV. The minimum test that ensures llvm-redobj forwards RISCVAttributeParser errors is sufficient.

[MaskRay]

llvm/test/tools/llvm-readobj/ELF/RISCV/invalid-attr-version.test

7

These diagnostics should start with error: or warning:

[MaskRay]

llvm/test/tools/llvm-readobj/ELF/RISCV/attribute.s

2

This should probably go to test/MC/RISCV or test/MC/ELF/RISCV. This is more about a test for assembly.

llvm/test/tools/llvm-readobj/ELF/RISCV/invalid-attr-section-size.test

2

We can have one single invalid-*.text. You can find plent of --docnum= examples in llvm-readobj/ELF/

As I mentioned, we don't need many tests testing invalid section contents. We just need to show llvm-readobj forwards RISCVAttributeParser diagnostics, which are already tested by llvm/unittests/

llvm/test/tools/llvm-readobj/ELF/RISCV/validate-attr-section.test

2

This can be merged into section-types.test, I think.

[HsiangKai]

llvm/test/tools/llvm-readobj/ELF/RISCV/attribute.s

2

It is not used to test assembly. It is used to test readelf/readelf to decode attribute section correctly.

llvm/test/tools/llvm-readobj/ELF/RISCV/invalid-attr-section-size.test

2

That's why I removed other invalid-attr*.test.

invalid-attr-section-size.test is used to test the error messages are handled by llvm-readobj. As I mentioned in the test case comments.
invalid-attr-version.test is used to test the format version is checked in llvm-readobj.

They are two different test cases.

llvm/test/tools/llvm-readobj/ELF/RISCV/validate-attr-section.test

2

These two test cases are used for different purpose. I prefer to keep these two test cases.

[MaskRay]

Thanks!

[jhenderson]

Sorry, I spotted the error handling is not using llvm-readobj's style. Please fix it.

llvm/test/tools/llvm-readobj/ELF/RISCV/invalid-attr-version.test

2

Let's add a top-level comment to this file explaining why this error exists.

llvm/tools/llvm-readobj/ELFDumper.cpp

2725–2729

Please use llvm-readobj's reportError function rather than hand-rolling your own error handling.

[HsiangKai]

Use reportError() to handle error messages.

[jhenderson]

llvm/test/tools/llvm-readobj/ELF/RISCV/invalid-attr-version.test

2

Delete "ELF" - the test is in the ELF directory, so it's obvious that this is testing ELF.

3

section -> sections

llvm/tools/llvm-readobj/ELFDumper.cpp

2726–2728

Thinking about this, this should probably be reportWarning. In general, we don't want the tool to stop processing other options as soon as it sees something bad, as it might well be able to perform those options without any problems.

[jhenderson]

LGTM, with two more reportError -> reportWarning changes.

llvm/tools/llvm-readobj/ELFDumper.cpp

2738

As with the case you've modified, please change this to reportWarning and then return/continue as appropriate.

2741

Ditto.

llvm/lib/Support/ELFAttributeParser.cpp

 Error ELFAttributeParser::parseSubsection(uint32_t length) {
   uint64_t end = cursor.tell() - sizeof(length) + length;
   StringRef vendorName = de.getCStrRef(cursor);
   if (sw) {
     sw->printNumber("SectionLength", length);
     sw->printString("Vendor", vendorName);
   }
 
   // Ignore unrecognized vendor-name.
   if (vendorName.lower() != vendor)
     return createStringError(errc::invalid_argument,
                              "unrecognized vendor-name: " + vendorName);
 
   while (cursor.tell() < end) {
     /// Tag_File | Tag_Section | Tag_Symbol   uleb128:byte-size
     uint8_t tag = de.getU8(cursor);
     uint32_t size = de.getU32(cursor);
     if (!cursor)
       return cursor.takeError();
 
     if (sw) {
       sw->printEnum("Tag", tag, makeArrayRef(tagNames));
       sw->printNumber("Size", size);
     }
     if (size < 5)
       return createStringError(errc::invalid_argument,
                                "invalid attribute size " + Twine(size) +
                                    " at offset 0x" +
                                    Twine::utohexstr(cursor.tell() - 5));
 
     StringRef scopeName, indexName;
     SmallVector<uint8_t, 8> indicies;
     switch (tag) {
     case ELFAttrs::File:
       scopeName = "FileAttributes";
while (!de.eof(cursor)) {
 
     if (sw) {
       sw->startLine() << "Section " << ++sectionNumber << " {\n";
       sw->indent();
     }
 
     if (sectionLength < 4 || cursor.tell() - 4 + sectionLength > section.size())
       return createStringError(errc::invalid_argument,
-                               "invalid subsection length " +
+                               "invalid section length " +
                                    Twine(sectionLength) + " at offset 0x" +
                                    utohexstr(cursor.tell() - 4));
 
     if (Error e = parseSubsection(sectionLength))
       return e;
     if (sw) {
       sw->unindent();
       sw->startLine() << "}\n";
     }
   }
 
   return cursor.takeError();
 }

llvm/test/MC/RISCV/attribute-with-option.s

+## When a user specifies an architecture extension which conflicts with an
+## architecture attribute, we use the architecture attribute instead of the
+## command line option.
+##
+## This test uses option '-mattr=+e' to specify the "e" extension. However,
+## there is an architecture attribute in the file to specify rv32i. We will
+## use rv32i to assemble the file instead of rv32e.
+
+# RUN: llvm-mc %s -triple=riscv32 -mattr=+e -filetype=obj -o - \
+# RUN:   | llvm-readobj -A - | FileCheck %s
+
+.attribute arch, "rv32i2p0"
+## Invalid operand for RV32E, because x16 is an invalid register for RV32E.
+## Use RV32I to assemble, since it will not trigger an assembly error.
+lui x16, 1
+
+## Check that the architecture attribute is not overridden by the command line
+## option.
+# CHECK:      Tag: 5
+# CHECK-NEXT: TagName: arch
+# CHECK-NEXT: Value: rv32i2p0

llvm/test/tools/llvm-readobj/ELF/RISCV/attribute.s

+## Test llvm-readobj & llvm-readelf can decode RISC-V attributes correctly.
+
+# RUN: llvm-mc -triple riscv32 -filetype obj -o %t.rv32.o %s
+# RUN: llvm-mc -triple riscv64 -filetype obj -o %t.rv64.o %s
+# RUN: llvm-readobj --arch-specific %t.rv32.o \
+# RUN:   | FileCheck %s --check-prefix=CHECK-OBJ
+# RUN: llvm-readelf -A %t.rv32.o \
+# RUN:   | FileCheck %s --check-prefix=CHECK-OBJ
+# RUN: llvm-readobj --arch-specific %t.rv64.o \
+# RUN:   | FileCheck %s --check-prefix=CHECK-OBJ
+# RUN: llvm-readelf -A %t.rv64.o \
+# RUN:   | FileCheck %s --check-prefix=CHECK-OBJ
+
+.attribute  Tag_stack_align, 16
+# CHECK-OBJ:      Tag: 4
+# CHECK-OBJ-NEXT: Value: 16
+# CHECK-OBJ-NEXT: TagName: stack_align
+# CHECK-OBJ-NEXT: Description: Stack alignment is 16-bytes
+
+.attribute  Tag_arch, "rv32i2p0_m2p0_a2p0_c2p0"
+# CHECK-OBJ:      Tag: 5
+# CHECK-OBJ-NEXT: TagName: arch
+# CHECK-OBJ-NEXT: Value: rv32i2p0_m2p0_a2p0_c2p0
+
+.attribute  Tag_unaligned_access, 0
+# CHECK-OBJ:      Tag: 6
+# CHECK-OBJ-NEXT: Value: 0
+# CHECK-OBJ-NEXT: TagName: unaligned_access
+# CHECK-OBJ-NEXT: Description: No unaligned access
+
+.attribute  Tag_priv_spec, 2
+# CHECK-OBJ:      Tag: 8
+# CHECK-OBJ-NEXT: TagName: priv_spec
+# CHECK-OBJ-NEXT: Value: 2
+
+.attribute  Tag_priv_spec_minor, 0
+# CHECK-OBJ:      Tag: 10
+# CHECK-OBJ-NEXT: TagName: priv_spec_minor
+# CHECK-OBJ-NEXT: Value: 0
+
+.attribute  Tag_priv_spec_revision, 0
+# CHECK-OBJ:      Tag: 12
+# CHECK-OBJ-NEXT: TagName: priv_spec_revision
+# CHECK-OBJ-NEXT: Value: 0

llvm/test/tools/llvm-readobj/ELF/RISCV/invalid-attr-section-size.test

+## This test case is used to ensure the error code is caught by llvm-readobj.
+
+# RUN: yaml2obj %s -D BITS=32 -o %t.32.o
+# RUN: llvm-readobj -A %t.32.o 2>&1 | FileCheck -DFILE=%t %s
+# RUN: yaml2obj %s -D BITS=64 -o %t.64.o
+# RUN: llvm-readobj -A %t.64.o 2>&1 | FileCheck -DFILE=%t %s
+
+# CHECK: warning: '[[FILE]].{{32|64}}.o': invalid section length 0 at offset 0x1
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS[[BITS]]
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_RISCV
+Sections:
+  - Name:    .riscv.attributes
+    Type:    SHT_RISCV_ATTRIBUTES
+## Version: 'A'(0x41), section length: 0
+    Content: 4100000000

llvm/test/tools/llvm-readobj/ELF/RISCV/invalid-attr-version.test

+## This test case is used to ensure llvm-readobj checks the version of
+## attribute sections correctly.
+
+# RUN: yaml2obj %s -D BITS=32 -o %t.32.o
+# RUN: llvm-readobj -A %t.32.o 2>&1 | FileCheck -DFILE=%t %s
+# RUN: yaml2obj %s -D BITS=64 -o %t.64.o
+# RUN: llvm-readobj -A %t.64.o 2>&1 | FileCheck -DFILE=%t %s
+
+# CHECK: warning: '[[FILE]].{{32|64}}.o': unrecognised FormatVersion: 0x42
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS[[BITS]]
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_RISCV
+Sections:
+  - Name:    .riscv.attributes
+    Type:    SHT_RISCV_ATTRIBUTES
+## Version: 'B'
+    Content: 42

llvm/test/tools/llvm-readobj/ELF/RISCV/lit.local.cfg

+if not 'RISCV' in config.root.targets:
+    config.unsupported = True

llvm/test/tools/llvm-readobj/ELF/RISCV/section-types.test

+## Show that all RISCV specific section types are properly printed for both
+## LLVM and GNU styles.
+
+# RUN: yaml2obj %s -o %t-riscv.o
+# RUN: llvm-readobj --section-headers %t-riscv.o | FileCheck %s --check-prefix=LLVM
+# RUN: llvm-readelf --section-headers %t-riscv.o | FileCheck %s --check-prefix=GNU
+
+# LLVM:      Name: .riscv.attributes (1)
+# LLVM-NEXT: Type: SHT_RISCV_ATTRIBUTES (0x70000003)
+
+# GNU: [ 1] .riscv.attributes RISCV_ATTRIBUTES
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_RISCV
+Sections:
+  - Name: .riscv.attributes
+    Type: SHT_RISCV_ATTRIBUTES

llvm/test/tools/llvm-readobj/ELF/RISCV/validate-attr-section.test

+## We only implement attribute section printing for little-endian encoding.
+
+# RUN: yaml2obj %s -o %t.o
+# RUN: llvm-readobj -A %t.o | FileCheck %s
+
+# CHECK: Attributes not implemented.
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+## Test big-endian encoding.
+  Data:    ELFDATA2MSB
+  Type:    ET_REL
+  Machine: EM_RISCV
+Sections:
+  - Name: .riscv.attributes
+    Type: SHT_RISCV_ATTRIBUTES

llvm/tools/llvm-readobj/ELFDumper.cpp

 #include "llvm/Support/Endian.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/MipsABIFlags.h"
+#include "llvm/Support/RISCVAttributeParser.h"
+#include "llvm/Support/RISCVAttributes.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cinttypes>
 #include <cstddef>
 #include <cstdint>
 #include <cstdlib>
 #include <iterator>

 template <typename ELFT> void ELFDumper<ELFT>::printLoadName() {
   W.printString("LoadName", SOName);
 }
 
 template <class ELFT> void ELFDumper<ELFT>::printArchSpecificInfo() {
   const ELFFile<ELFT> *Obj = ObjF->getELFFile();
   switch (Obj->getHeader()->e_machine) {
   case EM_ARM:
+  case EM_RISCV:
     printAttributes();
     break;
   case EM_MIPS: {
     ELFDumperStyle->printMipsABIFlags(ObjF);
     printMipsOptions();
     printMipsReginfo();
 
     MipsGOTParser<ELFT> Parser(Obj, ObjF->getFileName(), dynamic_table(),
                                dynamic_symbols());
     if (Parser.hasGot())
       ELFDumperStyle->printMipsGOT(Parser);
     if (Parser.hasPlt())
       ELFDumperStyle->printMipsPLT(Parser);
     break;
   }
   default:
     break;
   }
 }
 
-template <class ELFT> void ELFDumper<ELFT>::printAttributes() {
-  W.startLine() << "Attributes not implemented.\n";
-}
-
 namespace {
 
-template <> void ELFDumper<ELF32LE>::printAttributes() {
-  const ELFFile<ELF32LE> *Obj = ObjF->getELFFile();
-  if (Obj->getHeader()->e_machine != EM_ARM) {
+template <class ELFT> void ELFDumper<ELFT>::printAttributes() {
+  const ELFFile<ELFT> *Obj = ObjF->getELFFile();
+  if (!Obj->isLE()) {
     W.startLine() << "Attributes not implemented.\n";
     return;
   }
 
+  const unsigned Machine = Obj->getHeader()->e_machine;
+  assert((Machine == EM_ARM || Machine == EM_RISCV) &&
+         "Attributes not implemented.");
+
   DictScope BA(W, "BuildAttributes");
-  for (const ELFO::Elf_Shdr &Sec :
-       unwrapOrError(ObjF->getFileName(), Obj->sections())) {
-    if (Sec.sh_type != ELF::SHT_ARM_ATTRIBUTES)
+  for (const auto &Sec : unwrapOrError(ObjF->getFileName(), Obj->sections())) {
+    if (Sec.sh_type != ELF::SHT_ARM_ATTRIBUTES &&
+        Sec.sh_type != ELF::SHT_RISCV_ATTRIBUTES)
       continue;
 
     ArrayRef<uint8_t> Contents =
         unwrapOrError(ObjF->getFileName(), Obj->getSectionContents(&Sec));
     if (Contents[0] != ELFAttrs::Format_Version) {
-      errs() << "unrecognised FormatVersion: 0x"
-             << Twine::utohexstr(Contents[0]) << '\n';
+      reportWarning(createError(Twine("unrecognised FormatVersion: 0x") +
+                                Twine::utohexstr(Contents[0])),
+                    ObjF->getFileName());
       continue;
     }
-
     W.printHex("FormatVersion", Contents[0]);
     if (Contents.size() == 1)
       continue;
 
-    // TODO: Print error and delete the redundant FormatVersion check above.
+    // TODO: Delete the redundant FormatVersion check above.
+    if (Machine == EM_ARM) {
       if (Error E = ARMAttributeParser(&W).parse(Contents, support::little))
-      consumeError(std::move(E));
+        reportWarning(std::move(E), ObjF->getFileName());
+    } else if (Machine == EM_RISCV) {
+      if (Error E = RISCVAttributeParser(&W).parse(Contents, support::little))
+        reportWarning(std::move(E), ObjF->getFileName());
+    }
   }
 }
 
 template <class ELFT> class MipsGOTParser {
 public:
   TYPEDEF_ELF_TYPES(ELFT)
   using Entry = typename ELFO::Elf_Addr;
   using Entries = ArrayRef<Entry>;
case EM_MIPS_RS3_LE:
     case SHT_MIPS_OPTIONS:
       return "MIPS_OPTIONS";
     case SHT_MIPS_DWARF:
       return "MIPS_DWARF";
     case SHT_MIPS_ABIFLAGS:
       return "MIPS_ABIFLAGS";
     }
     break;
+  case EM_RISCV:
+    switch (Type) {
+    case SHT_RISCV_ATTRIBUTES:
+      return "RISCV_ATTRIBUTES";
+    }
   }
   switch (Type) {
   case SHT_NULL:
     return "NULL";
   case SHT_PROGBITS:
     return "PROGBITS";
   case SHT_SYMTAB:
     return "SYMTAB";

llvm/unittests/Support/ELFAttributeParserTest.cpp

static void testParseError(ArrayRef<uint8_t> bytes, const char *msg) {
   EXPECT_STREQ(toString(std::move(e)).c_str(), msg);
 }
 
 TEST(AttributeHeaderParser, UnrecognizedFormatVersion) {
   static const uint8_t bytes[] = {1};
   testParseError(bytes, "unrecognized format-version: 0x1");
 }
 
-TEST(AttributeHeaderParser, InvalidSubsectionLength) {
+TEST(AttributeHeaderParser, InvalidSectionLength) {
   static const uint8_t bytes[] = {'A', 3, 0, 0, 0};
-  testParseError(bytes, "invalid subsection length 3 at offset 0x1");
+  testParseError(bytes, "invalid section length 3 at offset 0x1");
 }
 
 TEST(AttributeHeaderParser, UnrecognizedVendorName) {
   static const uint8_t bytes[] = {'A', 7, 0, 0, 0, 'x', 'y', 0};
   testParseError(bytes, "unrecognized vendor-name: xy");
 }
 
 TEST(AttributeHeaderParser, UnrecognizedTag) {