[CHERIoT] Add __builtin_cheriot_sealing_type clang built-in

Author: xdoardo

cheriot-sealing-type-builtin.ll

@@ -0,0 +1,47 @@
+; ModuleID = 'clang/test/CodeGen/cheri/riscv/cheriot-sealing-type-builtin.c'
+source_filename = "clang/test/CodeGen/cheri/riscv/cheriot-sealing-type-builtin.c"
+target datalayout = "e-m:e-p:32:32-i64:64-n32-S128-pf200:64:64:64:32-A200-P200-G200"
+target triple = "riscv32cheriot-unknown-unknown"
+
+%struct.OpaqueSealingKeyType = type opaque
+
+@__import.sealing_type.static_sealing_test.StructSealingKey = external addrspace(200) constant %struct.OpaqueSealingKeyType #0
+@__import.sealing_type.static_sealing_test.EnumSealingKey = external addrspace(200) constant %struct.OpaqueSealingKeyType #1
+@__import.sealing_type.static_sealing_test.TypeDefSealingKey = external addrspace(200) constant %struct.OpaqueSealingKeyType #2
+@__import.sealing_type.static_sealing_test.int = external addrspace(200) constant %struct.OpaqueSealingKeyType #3
+
+; Function Attrs: noinline nounwind optnone
+define dso_local void @func() addrspace(200) #4 {
+  %1 = alloca ptr addrspace(200), align 8, addrspace(200)
+  %2 = alloca ptr addrspace(200), align 8, addrspace(200)
+  %3 = alloca ptr addrspace(200), align 8, addrspace(200)
+  %4 = alloca ptr addrspace(200), align 8, addrspace(200)
+  %5 = alloca ptr addrspace(200), align 8, addrspace(200)
+  %6 = alloca ptr addrspace(200), align 8, addrspace(200)
+  %7 = alloca ptr addrspace(200), align 8, addrspace(200)
+  store ptr addrspace(200) @__import.sealing_type.static_sealing_test.StructSealingKey, ptr addrspace(200) %1, align 8
+  store ptr addrspace(200) @__import.sealing_type.static_sealing_test.EnumSealingKey, ptr addrspace(200) %2, align 8
+  store ptr addrspace(200) @__import.sealing_type.static_sealing_test.TypeDefSealingKey, ptr addrspace(200) %3, align 8
+  store ptr addrspace(200) @__import.sealing_type.static_sealing_test.int, ptr addrspace(200) %4, align 8
+  store ptr addrspace(200) @__import.sealing_type.static_sealing_test.int, ptr addrspace(200) %5, align 8
+  store ptr addrspace(200) @__import.sealing_type.static_sealing_test.int, ptr addrspace(200) %6, align 8
+  store ptr addrspace(200) @__import.sealing_type.static_sealing_test.int, ptr addrspace(200) %7, align 8
+  ret void
+}
+
+attributes #0 = { "cheri-compartment"="static_sealing_test" "cheriot_sealing_key"="sealing_type.static_sealing_test.StructSealingKey" }
+attributes #1 = { "cheri-compartment"="static_sealing_test" "cheriot_sealing_key"="sealing_type.static_sealing_test.EnumSealingKey" }
+attributes #2 = { "cheri-compartment"="static_sealing_test" "cheriot_sealing_key"="sealing_type.static_sealing_test.TypeDefSealingKey" }
+attributes #3 = { "cheri-compartment"="static_sealing_test" "cheriot_sealing_key"="sealing_type.static_sealing_test.int" }
+attributes #4 = { noinline nounwind optnone "cheri-compartment"="static_sealing_test" "frame-pointer"="all" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="cheriot" "target-features"="+32bit,+c,+cap-mode,+e,+m,+relax,+xcheri,+zmmul,-a,-b,-d,-experimental-sdext,-experimental-sdtrig,-experimental-smctr,-experimental-ssctr,-experimental-svukte,-experimental-xqcia,-experimental-xqciac,-experimental-xqcicli,-experimental-xqcicm,-experimental-xqcics,-experimental-xqcicsr,-experimental-xqciint,-experimental-xqcilo,-experimental-xqcilsm,-experimental-xqcisls,-experimental-zalasr,-experimental-zicfilp,-experimental-zicfiss,-experimental-zvbc32e,-experimental-zvkgs,-f,-h,-i,-sha,-shcounterenw,-shgatpa,-shtvala,-shvsatpa,-shvstvala,-shvstvecd,-smaia,-smcdeleg,-smcsrind,-smdbltrp,-smepmp,-smmpm,-smnpm,-smrnmi,-smstateen,-ssaia,-ssccfg,-ssccptr,-sscofpmf,-sscounterenw,-sscsrind,-ssdbltrp,-ssnpm,-sspm,-ssqosid,-ssstateen,-ssstrict,-sstc,-sstvala,-sstvecd,-ssu64xl,-supm,-svade,-svadu,-svbare,-svinval,-svnapot,-svpbmt,-svvptc,-v,-xcheriot,-xcvalu,-xcvbi,-xcvbitmanip,-xcvelw,-xcvmac,-xcvmem,-xcvsimd,-xmipscmove,-xmipslsp,-xsfcease,-xsfvcp,-xsfvfnrclipxfqf,-xsfvfwmaccqqq,-xsfvqmaccdod,-xsfvqmaccqoq,-xsifivecdiscarddlone,-xsifivecflushdlone,-xtheadba,-xtheadbb,-xtheadbs,-xtheadcmo,-xtheadcondmov,-xtheadfmemidx,-xtheadmac,-xtheadmemidx,-xtheadmempair,-xtheadsync,-xtheadvdot,-xventanacondops,-xwchc,-za128rs,-za64rs,-zaamo,-zabha,-zacas,-zalrsc,-zama16b,-zawrs,-zba,-zbb,-zbc,-zbkb,-zbkc,-zbkx,-zbs,-zca,-zcb,-zcd,-zce,-zcf,-zcmop,-zcmp,-zcmt,-zdinx,-zfa,-zfbfmin,-zfh,-zfhmin,-zfinx,-zhinx,-zhinxmin,-zic64b,-zicbom,-zicbop,-zicboz,-ziccamoa,-ziccif,-zicclsm,-ziccrse,-zicntr,-zicond,-zicsr,-zifencei,-zihintntl,-zihintpause,-zihpm,-zimop,-zk,-zkn,-zknd,-zkne,-zknh,-zkr,-zks,-zksed,-zksh,-zkt,-ztso,-zvbb,-zvbc,-zve32f,-zve32x,-zve64d,-zve64f,-zve64x,-zvfbfmin,-zvfbfwma,-zvfh,-zvfhmin,-zvkb,-zvkg,-zvkn,-zvknc,-zvkned,-zvkng,-zvknha,-zvknhb,-zvks,-zvksc,-zvksed,-zvksg,-zvksh,-zvkt,-zvl1024b,-zvl128b,-zvl16384b,-zvl2048b,-zvl256b,-zvl32768b,-zvl32b,-zvl4096b,-zvl512b,-zvl64b,-zvl65536b,-zvl8192b" }
+
+!llvm.module.flags = !{!0, !1, !2, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = !{i32 1, !"wchar_size", i32 4}
+!1 = !{i32 1, !"target-abi", !"cheriot-baremetal"}
+!2 = !{i32 6, !"riscv-isa", !3}
+!3 = !{!"rv32e2p0_m2p0_c2p0_zmmul1p0_xcheri0p0"}
+!4 = !{i32 7, !"frame-pointer", i32 2}
+!5 = !{i32 8, !"SmallDataLimit", i32 0}
+!6 = !{!"clang version 20.1.3 (https://github.com/xdoardo/llvm-project 592752fee8b25c925a65fb40eeb8a496f1b0ee2c)"}

clang/include/clang/Basic/Builtins.td

@@ -4648,6 +4648,12 @@ def CheriConditionalSeal : Builtin {
   let Prototype = "void* __capability(void const* __capability,void const* __capability)";
 }
 
+def CHERIoTEmitSealingType : Builtin {
+  let Spellings = ["__builtin_cheriot_sealing_type"];
+  let Attributes = [NoThrow, Const, CustomTypeChecking];
+  let Prototype = "void*(char const*)";
+}
+
 // Safestack builtins.
 def GetUnsafeStackStart : Builtin {
   let Spellings = ["__builtin___get_unsafe_stack_start"];

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -155,6 +155,8 @@ def err_cheriot_non_addr_of_expr_on_sealed
           "the only valid operation on a sealed value is to take its address">;
 def err_cheriot_invalid_sealed_declaration
     : Error<"cannot declare a sealed variable as %0">;
+def err_cheriot_invalid_sealing_key_type_name
+    : Error<"the sealing key type name '%0' is not a valid identifier">;
 
 // C99 variable-length arrays
 def ext_vla : Extension<"variable length arrays are a C99 feature">,

clang/lib/CodeGen/CGBuiltin.cpp

@@ -6155,6 +6155,44 @@ RValue CodeGenFunction::EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
     return RValue::get(Builder.CreateIntrinsic(
         llvm::Intrinsic::cheri_cap_perms_check, {SizeTy}, {Cap, Perms}));
   }
+  case Builtin::BI__builtin_cheriot_sealing_type: {
+    const auto *ArgLit = dyn_cast<StringLiteral>(E->getArg(0));
+    assert(ArgLit && "Argument to built-in should be a string literal!");
+    auto SealingTypeName = ArgLit->getString().str();
+    SealingTypeName.erase(
+        std::remove_if(SealingTypeName.begin(), SealingTypeName.end(), isspace),
+        SealingTypeName.end());
+
+    auto CompartmentName = getLangOpts().CheriCompartmentName;
+    auto PrefixedImportName =
+        CHERIoTSealingKeyTypeAttr::getSealingTypeSymbolName(CompartmentName,
+                                                            SealingTypeName);
+    auto *Mod = &CGM.getModule();
+    auto MangledImportName = "__import." + PrefixedImportName;
+    auto *GV = Mod->getGlobalVariable(MangledImportName);
+
+    if (!GV) {
+      // This global exists only so that we have a pointer to it and is more
+      // akin to a GOT entry than a "real" global value: it just
+      // represents a pointer that we have a way of getting.
+
+      auto *OpaqueTypeName = "struct.OpaqueSealingKeyType";
+      llvm::StructType *OpaqueType =
+          llvm::StructType::getTypeByName(CGM.getLLVMContext(), OpaqueTypeName);
+      if (!OpaqueType)
+        OpaqueType = llvm::StructType::create(CGM.getModule().getContext(),
+                                              OpaqueTypeName);
+
+      GV = new GlobalVariable(CGM.getModule(), OpaqueType, true,
+                              GlobalValue::ExternalLinkage, nullptr,
+                              MangledImportName);
+      GV->addAttribute(CHERIoTSealingKeyTypeAttr::getAttrName(),
+                       PrefixedImportName);
+      GV->addAttribute("cheri-compartment", CompartmentName);
+    }
+
+    return RValue::get(GV);
+  }
   // Round to capability precision:
   // TODO: should we handle targets that don't have any precision constraints
   // here or in the backend?

clang/lib/Sema/SemaChecking.cpp

@@ -2920,6 +2920,24 @@ Sema::CheckBuiltinFunctionCall(FunctionDecl *FDecl, unsigned BuiltinID,
       return ExprError();
     break;
 
+  case Builtin::BI__builtin_cheriot_sealing_type: {
+    if (checkArgCount(TheCall, 1))
+      return ExprError();
+    auto *Arg = dyn_cast<StringLiteral>(TheCall->getArg(0));
+    if (!Arg)
+      return ExprError();
+    auto ArgLit = Arg->getString();
+    if (!isValidAsciiIdentifier(ArgLit)) {
+      std::string Escaped;
+      llvm::raw_string_ostream OS(Escaped);
+      llvm::printEscapedString(ArgLit, OS);
+      OS.flush();
+      Diag(Arg->getExprLoc(), diag::err_cheriot_invalid_sealing_key_type_name)
+          << Escaped;
+      return ExprError();
+    }
+    break;
+  }
   // OpenCL v2.0, s6.13.16 - Pipe functions
   case Builtin::BIread_pipe:
   case Builtin::BIwrite_pipe:

clang/test/CodeGen/cheri/riscv/cheriot-sealing-type-builtin.c

@@ -0,0 +1,51 @@
+// RUN: %clang_cc1 %s -o - "-triple" "riscv32cheriot-unknown-unknown-cheriotrtos" "-emit-llvm" "-cheri-compartment=static_sealing_test" "-mframe-pointer=none" "-mcmodel=small" "-target-abi" "cheriot" "-O0" "-Werror" -std=c2x | FileCheck %s
+
+
+struct StructSealingKey { };
+enum EnumSealingKey { SEALING_KEY_KIND1, SEALING_KEY_KIND2 };
+typedef enum EnumSealingKey TypeDefSealingKey;
+
+// CHECK: %struct.OpaqueSealingKeyType = type opaque
+// CHECK: @__import.sealing_type.static_sealing_test.StructSealingKey = external addrspace(200) constant %struct.OpaqueSealingKeyType #0
+// CHECK: @__import.sealing_type.static_sealing_test.EnumSealingKey = external addrspace(200) constant %struct.OpaqueSealingKeyType #1
+// CHECK: @__import.sealing_type.static_sealing_test.TypeDefSealingKey = external addrspace(200) constant %struct.OpaqueSealingKeyType #2
+// CHECK: @__import.sealing_type.static_sealing_test.int = external addrspace(200) constant %struct.OpaqueSealingKeyType #3
+
+// CHECK: define dso_local void @func() addrspace(200) #4 {
+void func() {
+
+// CHECK: entry:
+// CHECK:  %SealingKey1 = alloca ptr addrspace(200), align 8, addrspace(200)
+// CHECK:  %SealingKey2 = alloca ptr addrspace(200), align 8, addrspace(200)
+// CHECK:  %SealingKey3 = alloca ptr addrspace(200), align 8, addrspace(200)
+// CHECK:  %SealingKey4 = alloca ptr addrspace(200), align 8, addrspace(200)
+// CHECK:  %SealingKey5 = alloca ptr addrspace(200), align 8, addrspace(200)
+// CHECK:  %SealingKey6 = alloca ptr addrspace(200), align 8, addrspace(200)
+// CHECK:  %SealingKey7 = alloca ptr addrspace(200), align 8, addrspace(200)
+
+// CHECK:  store ptr addrspace(200) @__import.sealing_type.static_sealing_test.StructSealingKey, ptr addrspace(200) %SealingKey1, align 8
+  struct StructSealingKey *SealingKey1 = __builtin_cheriot_sealing_type("StructSealingKey");
+
+// CHECK:  store ptr addrspace(200) @__import.sealing_type.static_sealing_test.EnumSealingKey, ptr addrspace(200) %SealingKey2, align 8
+  enum EnumSealingKey *SealingKey2 = __builtin_cheriot_sealing_type("EnumSealingKey");
+
+// CHECK:  store ptr addrspace(200) @__import.sealing_type.static_sealing_test.TypeDefSealingKey, ptr addrspace(200) %SealingKey3, align 8
+  TypeDefSealingKey *SealingKey3 = __builtin_cheriot_sealing_type("TypeDefSealingKey");
+
+// CHECK:  store ptr addrspace(200) @__import.sealing_type.static_sealing_test.int, ptr addrspace(200) %SealingKey4, align 8
+  int *SealingKey4 = __builtin_cheriot_sealing_type("int");
+
+// CHECK:  store ptr addrspace(200) @__import.sealing_type.static_sealing_test.int, ptr addrspace(200) %SealingKey5, align 8
+  int *SealingKey5 = __builtin_cheriot_sealing_type("int");
+// CHECK:  store ptr addrspace(200) @__import.sealing_type.static_sealing_test.int, ptr addrspace(200) %SealingKey6, align 8
+  int *SealingKey6 = __builtin_cheriot_sealing_type("int");
+// CHECK:  store ptr addrspace(200) @__import.sealing_type.static_sealing_test.int, ptr addrspace(200) %SealingKey7, align 8
+  int *SealingKey7 = __builtin_cheriot_sealing_type("int");
+
+// CHECK: ret void
+}
+
+// CHECK: attributes #0 = { "cheri-compartment"="static_sealing_test" "cheriot_sealing_key"="sealing_type.static_sealing_test.StructSealingKey" }
+// CHECK: attributes #1 = { "cheri-compartment"="static_sealing_test" "cheriot_sealing_key"="sealing_type.static_sealing_test.EnumSealingKey" }
+// CHECK: attributes #2 = { "cheri-compartment"="static_sealing_test" "cheriot_sealing_key"="sealing_type.static_sealing_test.TypeDefSealingKey" }
+// CHECK: attributes #3 = { "cheri-compartment"="static_sealing_test" "cheriot_sealing_key"="sealing_type.static_sealing_test.int" }

clang/test/Sema/cheri/cheriot-sealing-type-builtin.c

@@ -0,0 +1,11 @@
+// RUN: %riscv32_cheri_cc1 "-triple" "riscv32cheriot-unknown-unknown" "-target-abi" "cheriot" -verify %s 
+
+void func() {
+  int *k1 = __builtin_cheriot_sealing_type(MySealingType); // expected-error{{use of undeclared identifier 'MySealingType'}}
+  int *k2 = __builtin_cheriot_sealing_type("This is my key"); // expected-error{{the sealing key type name 'This is my key' is not a valid identifier}}
+  int *k3 = __builtin_cheriot_sealing_type("αβγδ"); // expected-error{{the sealing key type name '\CE\B1\CE\B2\CE\B3\CE\B4' is not a valid identifier}}
+  int *k4 = __builtin_cheriot_sealing_type("a\0b"); // expected-error{{the sealing key type name 'a\00b' is not a valid identifier}}
+  int *k5 = __builtin_cheriot_sealing_type("a\"b"); // expected-error{{the sealing key type name 'a\22b' is not a valid identifier}}
+  int *k6 = __builtin_cheriot_sealing_type("a\nb"); // expected-error{{the sealing key type name 'a\0Ab' is not a valid identifier}}
+  int *k7 = __builtin_cheriot_sealing_type("a\bb"); // expected-error{{the sealing key type name 'a\08b' is not a valid identifier}}
+}

llvm/include/llvm/IR/Attributes.h

@@ -1612,6 +1612,23 @@ class CHERIoTSealedValueAttr {
   /// Get the name of the attribute.
   static const std::string getAttrName() { return "cheriot_sealed_value"; }
 };
+
+/// Represents the LLVM-level attribute that is used to signal
+/// that a global (variable) represents a sealing key type.
+class CHERIoTSealingKeyTypeAttr {
+public:
+  /// Get the name of the attribute.
+  static const std::string getAttrName() { return "cheriot_sealing_key"; }
+
+  /// Get the mangled name of the symbol representing the sealing key.
+  static const std::string
+  getSealingTypeSymbolName(StringRef CompartmentName,
+                           StringRef SealingKeyTypeName) {
+    return "sealing_type." + CompartmentName.str() + "." +
+           SealingKeyTypeName.str();
+  }
+};
+
 } // end namespace llvm
 
 #endif // LLVM_IR_ATTRIBUTES_H