[llvm-readobj] Support GNU_PROPERTY_X86_FEATURE_1_AND notes in .note.gnu.property

[mike.dvoretsky]

Summary

This patch allows parsing GNU_PROPERTY_X86_FEATURE_1_AND notes in .note.gnu.property sections. These notes indicate that the object file is built to support Intel CET.

[grimar]

LGTM

llvm/include/llvm/BinaryFormat/ELF.h

enum {
   NT_GNU_GOLD_VERSION = 4,
   NT_GNU_PROPERTY_TYPE_0 = 5,
 };
 
 // Property types used in GNU_PROPERTY_TYPE_0 notes.
 enum {
   GNU_PROPERTY_STACK_SIZE = 1,
   GNU_PROPERTY_NO_COPY_ON_PROTECTED = 2,
+  GNU_PROPERTY_X86_FEATURE_1_AND = 0xc0000002
+};
+
+// CET properties
+enum {
+  GNU_PROPERTY_X86_FEATURE_1_IBT = 1 << 0,
+  GNU_PROPERTY_X86_FEATURE_1_SHSTK = 1 << 1
 };
 
 // AMDGPU specific notes.
 enum {
   // Note types with values between 0 and 9 (inclusive) are reserved.
   NT_AMD_AMDGPU_HSA_METADATA = 10,
   NT_AMD_AMDGPU_ISA = 11,
   NT_AMD_AMDGPU_PAL_METADATA = 12

llvm/test/tools/llvm-readobj/note-gnu-property.s

 // REQUIRES: x86-registered-target
 // RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux-gnu %s -o %t
 // RUN: llvm-readobj -elf-output-style GNU --notes %t | FileCheck %s
 
-// CHECK:      Displaying notes found at file offset 0x00000040 with length 0x00000070:
+// CHECK:      Displaying notes found at file offset 0x00000040 with length 0x000000b8:
 // CHECK-NEXT:   Owner                 Data size       Description
-// CHECK-NEXT:   GNU                   0x00000060      NT_GNU_PROPERTY_TYPE_0 (property note)
+// CHECK-NEXT:   GNU                   0x000000a8      NT_GNU_PROPERTY_TYPE_0 (property note)
 // CHECK-NEXT:     Properties:  stack size: 0x100
 // CHECK-NEXT:     stack size: 0x100
 // CHECK-NEXT:     no copy on protected
+// CHECK-NEXT:     X86 features: SHSTK
+// CHECK-NEXT:     X86 features: IBT, SHSTK
+// CHECK-NEXT:     X86 features: none
 // CHECK-NEXT:     <application-specific type 0xfefefefe>
 // CHECK-NEXT:     stack size: <corrupt length: 0x0>
 // CHECK-NEXT:     stack size: <corrupt length: 0x4> 
 // CHECK-NEXT:     no copy on protected <corrupt length: 0x1>
+// CHECK-NEXT:     X86 features: <corrupt length: 0x0>
+// CHECK-NEXT:     X86 features: IBT, <unknown flags: 0xf000f000f000f000>
 // CHECK-NEXT:     <corrupt type (0x2) datasz: 0x1>
 
 .section ".note.gnu.property", "a"
 .align 4 
   .long 4           /* Name length is always 4 ("GNU") */
   .long end - begin /* Data length */
   .long 5           /* Type: NT_GNU_PROPERTY_TYPE_0 */
   .asciz "GNU"      /* Name */
   .p2align 3
 begin:
   .long 1           /* Type: GNU_PROPERTY_STACK_SIZE */
   .long 8           /* Data size */
   .quad 0x100       /* Data (stack size) */
   .p2align 3        /* Align to 8 byte for 64 bit */
-  
   /* Test we handle alignment properly */
   .long 1           /* Type: GNU_PROPERTY_STACK_SIZE */
   .long 8           /* Data size */
   .long 0x100       /* Data (stack size) */
   .p2align 3        /* Align to 8 byte for 64 bit */
   
   .long 2           /* Type: GNU_PROPERTY_NO_COPY_ON_PROTECTED */
   .long 0           /* Data size */
   .p2align 3        /* Align to 8 byte for 64 bit */
-  
+  /* CET property note */
+  .long 0xc0000002  /* Type: GNU_PROPERTY_X86_FEATURE_1_AND */
+  .long 8           /* Data size */
+  .quad 2           /* GNU_PROPERTY_X86_FEATURE_1_SHSTK */
+  .p2align 3        /* Align to 8 byte for 64 bit */
+
+  /* CET property note with padding */
+  .long 0xc0000002  /* Type: GNU_PROPERTY_X86_FEATURE_1_AND */
+  .long 4           /* Data size */
+  .long 3           /* Full CET support */
+  .p2align 3        /* Align to 8 byte for 64 bit */
+
+  .long 0xc0000002  /* Type: GNU_PROPERTY_X86_FEATURE_1_AND */
+  .long 8           /* Data size */
+  .quad 0           /* Empty flags, not an error */
+  .p2align 3        /* Align to 8 byte for 64 bit */
+  
   /* All notes below are broken. Test we are able to report them. */
   
   /* Broken note type */
   .long 0xfefefefe  /* Invalid type for testing */
   .long 0           /* Data size */
   .p2align 3        /* Align to 8 byte for 64 bit */
   
   /* GNU_PROPERTY_STACK_SIZE with zero stack size */
   .long 1           /* Type: GNU_PROPERTY_STACK_SIZE */
   .long 0           /* Data size */
   .p2align 3        /* Align to 8 byte for 64 bit */
   
   /* GNU_PROPERTY_STACK_SIZE with data size 4 (should be 8) */
   .long 1           /* Type: GNU_PROPERTY_STACK_SIZE */
   .long 4           /* Data size */
   .long 0x100       /* Data (stack size) */
   .p2align 3        /* Align to 8 byte for 64 bit */
   
   /* GNU_PROPERTY_NO_COPY_ON_PROTECTED with pr_datasz and some data */
   .long 2           /* Type: GNU_PROPERTY_NO_COPY_ON_PROTECTED */
   .long 1           /* Data size (corrupted) */
   .byte 1           /* Data */
   .p2align 3        /* Align to 8 byte for 64 bit */
-  
+  /* CET note with size zero */
+  .long 0xc0000002  /* Type: GNU_PROPERTY_X86_FEATURE_1_AND */
+  .long 0           /* Data size */
+  .p2align 3        /* Align to 8 byte for 64 bit */
+
+  /* CET note with bad flags */
+  .long 0xc0000002         /* Type: GNU_PROPERTY_X86_FEATURE_1_AND */
+  .long 8                  /* Data size */
+  .quad 0xf000f000f000f001 /* GNU_PROPERTY_X86_FEATURE_1_IBT and bad bits */
+  .p2align 3               /* Align to 8 byte for 64 bit */
+  
   /* GNU_PROPERTY_NO_COPY_ON_PROTECTED with pr_datasz and without data */
   .long 2           /* Type: GNU_PROPERTY_NO_COPY_ON_PROTECTED */
   .long 1           /* Data size (corrupted) */
   .p2align 3        /* Align to 8 byte for 64 bit */
 end:

llvm/tools/llvm-readobj/ELFDumper.cpp

static void printGNUProperty(raw_ostream &OS, uint32_t Type, uint32_t DataSize,
                              ArrayRef<uint8_t> Data) {
   switch (Type) {
   default:
     OS << format("    <application-specific type 0x%x>\n", Type);
     return;
   case GNU_PROPERTY_STACK_SIZE: {
     OS << "    stack size: ";
     if (DataSize == sizeof(typename ELFT::uint))
-      OS << format("0x%x\n",
+      OS << format("0x%lx\n",
                    (uint64_t)(*(const typename ELFT::Addr *)Data.data()));
     else
       OS << format("<corrupt length: 0x%x>\n", DataSize);
     break;
   }
   case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
     OS << "    no copy on protected";
     if (DataSize)
       OS << format(" <corrupt length: 0x%x>", DataSize);
     OS << "\n";
     break;
+  case GNU_PROPERTY_X86_FEATURE_1_AND:
+    OS << "    X86 features: ";
+    if (DataSize != 4 && DataSize != 8) {
+      OS << format("<corrupt length: 0x%x>\n", DataSize);
+      break;
+    }
+    uint64_t CFProtection =
+        (DataSize == 4)
+            ? support::endian::read32<ELFT::TargetEndianness>(Data.data())
+            : support::endian::read64<ELFT::TargetEndianness>(Data.data());
+    if (CFProtection == 0) {
+      OS << "none\n";
+      break;
+    }
+    if (CFProtection & GNU_PROPERTY_X86_FEATURE_1_IBT) {
+      OS << "IBT";
+      CFProtection &= ~GNU_PROPERTY_X86_FEATURE_1_IBT;
+      if (CFProtection)
+        OS << ", ";
+    }
+    if (CFProtection & GNU_PROPERTY_X86_FEATURE_1_SHSTK) {
+      OS << "SHSTK";
+      CFProtection &= ~GNU_PROPERTY_X86_FEATURE_1_SHSTK;
+      if (CFProtection)
+        OS << ", ";
+    }
+    if (CFProtection)
+      OS << format("<unknown flags: 0x%lx>", CFProtection);
+    OS << "\n";
+    break;
   }
 }
 
 template <typename ELFT>
 static void printGNUNote(raw_ostream &OS, uint32_t NoteType,
                          ArrayRef<typename ELFT::Word> Words, size_t Size) {
   using Elf_Word = typename ELFT::Word;