[CHERIoT] Add a "cheriot capability" memory/register formatter to LLDB.

Author: resistor

lldb/include/lldb/lldb-enumerations.h

@@ -195,11 +195,12 @@ enum Format {
                          ///< character arrays that can contain non printable
                          ///< characters
   eFormatAddressInfo,    ///< Describe what an address points to (func + offset
-                      ///< with file/line, symbol + offset, data, etc)
-  eFormatHexFloat,    ///< ISO C99 hex float string
-  eFormatInstruction, ///< Disassemble an opcode
-  eFormatVoid,        ///< Do not print this
+                         ///< with file/line, symbol + offset, data, etc)
+  eFormatHexFloat,       ///< ISO C99 hex float string
+  eFormatInstruction,    ///< Disassemble an opcode
+  eFormatVoid,           ///< Do not print this
   eFormatUnicode8,
+  eFormatCheriotCapability,
   kNumFormats
 };
 

lldb/source/Commands/CommandObjectMemory.cpp

@@ -1354,6 +1354,7 @@ class CommandObjectMemoryWrite : public CommandObjectParsed {
       case eFormatAddressInfo:
       case eFormatHexFloat:
       case eFormatInstruction:
+      case eFormatCheriotCapability:
       case eFormatVoid:
         result.AppendError("unsupported format for writing memory");
         return;

lldb/source/Core/DumpDataExtractor.cpp

@@ -413,6 +413,114 @@ lldb::offset_t lldb_private::DumpDataExtractor(
     }
 
     switch (item_format) {
+    case eFormatCheriotCapability: {
+      if (item_byte_size != 8) {
+        s->Printf("error: cheriot capabilities must be 8 bytes");
+        return offset;
+      }
+
+      uint64_t uval64 = DE.GetMaxU64(&offset, item_byte_size);
+      uint32_t addr = uval64;
+      uint32_t meta = (uval64 >> 32);
+      unsigned B = meta & 0x1FF;
+      unsigned T = (meta >> 9) & 0x1FF;
+      unsigned E = (meta >> 18) & 0xF;
+      unsigned otype = (meta >> 22) & 0x7;
+      unsigned perms = (meta >> 25) & 0x3F;
+      unsigned R = (meta >> 31) & 1;
+
+      bool LD = false;
+      bool MC = false;
+      bool SD = false;
+      bool SL = false;
+      bool LM = false;
+      bool LG = false;
+      bool SR = false;
+      bool EX = false;
+      bool U0 = false;
+      bool SE = false;
+      bool US = false;
+
+      bool p0 = perms & 0b1;
+      bool p1 = perms & 0b10;
+      bool p2 = perms & 0b100;
+      bool p3 = perms & 0b1000;
+      bool p4 = perms & 0b10000;
+      bool GL = perms & 0b100000;
+
+      if (p4 && p3) {
+        LD = MC = SD = true;
+        SL = p2;
+        LM = p1;
+        LD = p0;
+      } else if (p4 && !p3 && p2) {
+        LD = MC = true;
+        LM = p1;
+        LG = p0;
+      } else if (p4 && !p3 && !p2 && !p1 && !p0) {
+        SD = MC = true;
+      } else if (p4 && !p3 && !p2) {
+        LD = p1;
+        SD = p0;
+      } else if (!p4 && p3) {
+        EX = LD = MC = true;
+        SR = p2;
+        LM = p1;
+        LG = p0;
+      } else {
+        U0 = p2;
+        SE = p1;
+        US = p0;
+      }
+
+      std::string perm_string;
+      perm_string += GL ? 'G' : '-';
+      perm_string += ' ';
+      perm_string += LD ? 'R' : '-';
+      perm_string += SD ? 'W' : '-';
+      perm_string += MC ? 'c' : '-';
+      perm_string += LG ? 'g' : '-';
+      perm_string += LM ? 'm' : '-';
+      perm_string += SL ? 'l' : '-';
+      perm_string += ' ';
+      perm_string += EX ? 'X' : '-';
+      perm_string += SR ? 'a' : '-';
+      perm_string += ' ';
+      perm_string += SE ? 'S' : '-';
+      perm_string += US ? 'U' : '-';
+      perm_string += U0 ? '0' : '-';
+
+      if (otype != 0 && !EX)
+        otype += 8;
+
+      constexpr const char *otypes[] = {
+          ", unsealed",
+          ", IRQ inherit forward sentry",
+          ", IRQ disable forward sentry",
+          ", IRQ enable forward sentry",
+          ", IRQ disable return sentry",
+          ", IRQ enable return sentry",
+      };
+
+      unsigned e = (E != 15) ? E : 24;
+      uint64_t a_top = addr >> (e + 9);
+      uint64_t a_mid = (addr >> e) & 0x1FF;
+      uint64_t a_hi = (a_mid < B) ? 1 : 0;
+      uint64_t t_hi = (T < B) ? 1 : 0;
+      uint64_t c_b = -a_hi;
+      uint64_t c_t = t_hi - a_hi;
+      uint64_t a_top_base = a_top + c_b;
+      uint64_t a_top_top = a_top + c_t;
+      uint64_t base = ((a_top_base << 9) + B) << e;
+      uint64_t top = ((a_top_top << 9) + T) << e;
+
+      s->Printf(
+          "0x%08x {0x%08llx-0x%08llx l:0x%09llx} p=[%s] otype=[%d%s] R=%d",
+          addr, base, top, (top - base), perm_string.c_str(), otype,
+          ((otype < sizeof(otypes)) ? otypes[otype] : ""), R);
+
+      break;
+    }
     case eFormatBoolean:
       if (item_byte_size <= 8)
         s->Printf("%s", DE.GetMaxU64Bitfield(&offset, item_byte_size,

lldb/source/DataFormatters/FormatManager.cpp

@@ -72,6 +72,7 @@ static constexpr FormatInfo g_format_infos[] = {
     {eFormatInstruction, 'i', "instruction"},
     {eFormatVoid, 'v', "void"},
     {eFormatUnicode8, 'u', "unicode8"},
+    {eFormatCheriotCapability, '\0', "cheriot capability"},
 };
 
 static_assert((sizeof(g_format_infos) / sizeof(g_format_infos[0])) ==