Cheri-research/cheri-cap-lib
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

Add extra field called "Delta" #2

New Issue
Closed
opened 2026-01-14 15:31:39 +00:00 by me · 3 comments
me commented 2026-01-14 15:31:39 +00:00
Owner
Copy Link

Extend the Cheri bounds by 44 bits and ensure the model checker does not break while doing this.

Extend the Cheri bounds by 44 bits and ensure the model checker does not break while doing this.
me changed title from Add extra filed called "Delta" to Add extra field called "Delta" 2026-01-14 15:31:53 +00:00
me commented 2026-01-14 15:32:53 +00:00
Author
Owner
Copy Link
  • Add extra field.
  • Add function that can add the value to the 44 bit filed.
- [x] Add extra field. - [x] Add function that can add the value to the 44 bit filed.
me self-assigned this 2026-01-14 15:39:02 +00:00
me added this to the FAT alloc with RISCV project 2026-01-14 15:41:26 +00:00
me moved this to In Progress in FAT alloc with RISCV on 2026-01-14 15:41:44 +00:00
me commented 2026-01-14 23:21:06 +00:00
Author
Owner
Copy Link

Debug trace

CheriCC_FAT

import DefaultValue :: *;
import CHERICap     :: *;

typedef 4   UPermW;
typedef 14  MW;
typedef 6   ExpW;
typedef 18  OTypeW;
typedef `FLAGSW FlagsW;
typedef 64  CapAddrW;
typedef 128 CapW;

// The Address type is used to represent the full sized address returned to the
// consuming pipeline. In cases where fewer than CapAddrW bits are stored to
// represent a memory address (and remaining bits are usable for storing extra
// metadata), returning a value of type Address is currently expected to sign
// extend the address.
// SizeOf#(Address) should be greater or equal to CapAddrW
typedef CapAddrW AddressW;
typedef Bit#(AddressW)     Address;
typedef TDiv#(ExpW,2)      HalfExpW;
typedef TSub#(MW,HalfExpW) UpperMW;

// The compressed bounds field type
typedef TSub#(TMul#(MW,2),1) CBoundsW;
typedef Bit#(CBoundsW) CBounds;
// The CapAddr types
typedef Bit#(CapAddrW)          CapAddr;
typedef Bit#(TAdd#(CapAddrW,1)) CapAddrPlus1;
typedef Bit#(TAdd#(CapAddrW,2)) CapAddrPlus2;

// The Hardware permissions type
typedef struct {
  Bool permit_set_CID;
  Bool access_sys_regs;
  Bool permit_unseal;
  Bool permit_ccall;
  Bool permit_seal;
  Bool permit_store_ephemeral_cap;
  Bool permit_store_cap;
  Bool permit_load_cap;
  Bool permit_store;
  Bool permit_load;
  Bool permit_execute;
  Bool non_ephemeral;
} HPerms deriving(Bits, Eq, FShow); // 12 bits

// The permissions field, including both "soft" and "hard" permission bits.
typedef struct {
  Bit#(UPermW) soft;
  HPerms       hard;
} Perms deriving(Bits, Eq, FShow);
typedef SizeOf#(Perms) PermsW;

// The reserved bits
typedef TSub#(CapW, TAdd#( CapAddrW
                         , TAdd#( OTypeW
                                , TAdd#( CBoundsW
                                       , TAdd#(PermsW, FlagsW))))) ResW;
                                       
typedef struct {
  Bool         isCapability;
  Perms        perms;
  Bit#(ResW)   reserved;
  Bit#(FlagsW) flags;
  Bit#(OTypeW) otype;
  CBounds      bounds;
  CapAddr      address;
} CapabilityInMemory deriving (Bits, Eq, FShow); // CapW + 1 (tag bit)


// The full capability structure as Bits, including the "tag" bit.
typedef Bit#(TAdd#(CapW,1)) Capability;
// not including the tag bit
typedef Bit#(CapW) CapBits;

// Bit type of the debug capability
typedef Bit#(CapW) DebugCap;
// Format of the cheri concentrate capability
typedef enum {Exp0, EmbeddedExp} Format deriving (Bits, Eq, FShow);
// Exponent type
typedef UInt#(ExpW) Exp;
// Type for capability otype field
typedef VnD#(Bit#(OTypeW)) CType;
Bit#(OTypeW) otype_max      = -5;
Bit#(OTypeW) otype_unsealed = -1;
Bit#(OTypeW) otype_sentry   = -2;
Bit#(OTypeW) otype_res0     = -3;
Bit#(OTypeW) otype_res1     = -4;


// unpacked capability format
typedef struct {
  Bool           isCapability;
  Bit#(CapAddrW) address;
  Bit#(MW)       addrBits;
  Perms          perms;
  Bit#(FlagsW)   flags;
  Bit#(ResW)     reserved;
  Bit#(OTypeW)   otype;
  Format         format;
  Bounds         bounds;
} CapFat deriving (Bits);

// Exponent that pushes the implied +1 of the top 1 bit outside the address space
Exp resetExp = fromInteger(valueOf(TSub#(TAdd#(CapAddrW,2),MW)));

Bit#(MW) resetTop = {2'b01,0};
typedef struct {
  Exp exp;
  Bit#(MW) topBits;
  Bit#(MW) baseBits;
} Bounds deriving (Bits, Eq, FShow);
instance DefaultValue #(Bounds);
  defaultValue = Bounds {
      exp     : resetExp
    , topBits : resetTop
    , baseBits: 0 };
endinstance
instance DefaultValue #(CapFat);
  defaultValue = CapFat {
      isCapability: True
    , perms       : unpack(~0)
    , flags       : 0
    , reserved    : 0
    , otype       : otype_unsealed
    , format      : EmbeddedExp
    , bounds      : defaultValue
    , address     : 0
    , addrBits    : 0 };
endinstance

CapFat null_cap = CapFat {
    isCapability: False
  , perms       : unpack(0)
  , flags       : 0
  , reserved    : 0
  , otype       : otype_unsealed
  , format      : EmbeddedExp
  , bounds      : defaultValue
  , address     : 0
  , addrBits    : 0 };

///////////////////////////////////////////////
// CHERI CONCENTRATE, example 128-bit format //
///////////////////////////////////////////////
// In memory representation //
////////////////////////////////////////////////////////////////////////////////
/*
XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX
XXX Note that the Flags field does not currently appear in the drawing below
XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX

                    Embedded Exp
127___124_123_112_111_109_108__91__90_89_________________________78_77__________________________64
|        |       |       |       |   |                             |                             |
| uperms | perms |  res  | otype | 0 |                    top<11:0>|                   base<13:0>| Exp0
| uperms | perms |  res  |       | 1 |             top<11:3>|e<5:3>|            base<13:3>|e<2:0>| EmbeddedExp
|________|_______|_______|_______|___|_____________________________|_____________________________|
63_______________________________________________________________________________________________0
|                                                                                                |
|                                      address                                                   |
|________________________________________________________________________________________________|

reconstructing most significant top bits:
top<20:19> = base<20:19> + carry_out + len_correction
     where
             carry_out      = 1 if top<18:0> < base <18:0>
                              0 otherwise
             len_correction = 0 if Exp0
                              1 otherwise
*/

// These three bounds formats help with the decBounds function.
typedef struct {
  Bool              embeddedExp;
  Bit#(TSub#(MW,2)) top;
  Bit#(MW)          base;
} BoundsExp0 deriving(Bits, Eq, FShow);

typedef struct {
  Bool                              embeddedExp;
  Bit#(TSub#(MW,TAdd#(HalfExpW,2))) topUpperBits;
  Bit#(HalfExpW)                    expTopHalf;
  Bit#(TSub#(MW,HalfExpW))          baseUpperBits;
  Bit#(HalfExpW)                    expBotHalf;
} BoundsEmbeddedExp deriving(Bits, Eq, FShow);

typedef struct {
  Bit#(3) repBoundTopBits;
  Bool    topHi;
  Bool    baseHi;
  Bool    addrHi;
  Int#(2) topCorrection;
  Int#(2) baseCorrection;
} MetaInfo deriving(Bits, Eq, FShow);

Function shapes

1. function Fmt showArchitectural(CapFat cap)

2. instance FShow#(CapFat);
  function Fmt fshow(CapFat cap)

3. // unpack a memory representation of the capability
function CapFat unpackCap(Capability thin);

4. // pack the fat capability into the memory representation
function Capability packCap(CapFat fat);

5. // Interface functions
//------------------------------------------------------------------------------
function BoundsInfo#(CapAddrW) getBoundsInfoFat (CapFat cap, TempFields tf)

6. function CapAddr getBotFat(CapFat cap, TempFields tf);

7. function CapAddrPlus1 getTopFat(CapFat cap, TempFields tf);

function CapAddr getLengthFat(CapFat cap, TempFields tf);

function Address getOffsetFat(CapFat cap, TempFields tf);

function CapFat setCapPointer(CapFat cap, CapAddr pointer);

function Bit#(n) smearMSBRight(Bit#(n) x);

function SetBoundsReturn#(CapFat, CapAddrW) setBoundsFat(CapFat cap, Address lengthFull, TempFields tf);

function CapFat seal(CapFat cap, TempFields tf, CType otype);

function CapFat unseal(CapFat cap, x _);

function VnD#(CapFat) incOffsetFat( CapFat cap
                                  , CapAddr pointer
                                  , CapAddr offset // this is the increment in inc offset, and the offset in set offset
                                  , TempFields tf
                                  , Bool setOffset);
                                  
function VnD#(CapFat) setAddress(CapFat cap, CapAddr address, TempFields tf);

function Tuple2#(Format, Bounds) decBounds (CBounds raw);

function CBounds encBounds (Format format, Bounds bounds);

function MetaInfo getMetaInfo (CapFat cap);

instance CHERICap #(CapMem, OTypeW, FlagsW, CapAddrW, CapW, TSub #(MW, 3));

function isValidCap (capMem);

function getFlags (capMem);

function setFlags (capMem, f);

function getHardPerms (capMem);

// capability in-memory architectural representation
  //////////////////////////////////////////////////////////////////////////////
  function getMeta (capMem);
 
function getAddr (capMem);

 function fromMem(x) = unpack(pack(x));
 function toMem(x) = unpack(pack(x));
 
function setAddrUnsafe (capMem, address);

function addAddrUnsafe (capMem, inc)

// CapReg CHERICap instance
////////////////////////////////////////////////////////////////////////////////
// Note: commented out methods have a provided default implementation in the
//       CHERICap typeclass definition

instance CHERICap #(CapReg, OTypeW, FlagsW, CapAddrW, CapW, TSub #(MW, 3));

function isValidCap (x) = x.isCapability;
function setValidCap (cap, tag);
function setValidCap (cap, tag);
function setFlags (cap, flags);

function getHardPerms (cap)
function setHardPerms (cap, perms)

function getSoftPerms (cap) = zeroExtend (cap.perms.soft);

function setSoftPerms (cap, perms);

function getKind (cap) = case (cap.otype)

function setKind (cap, kind)

function validAsType (dummy, checkType)

  // capability in-memory architectural representation
  //////////////////////////////////////////////////////////////////////////////
  function getMeta (capReg)
  
function getAddr (capReg)

function fromMem (x)

function toMem (x)

function isDerivable (cap)

instance CHERICap #(CapPipe, OTypeW, FlagsW, CapAddrW, CapW, TSub#(MW, 3));

  //Functions supported by CapReg are just passed through
  
typedef 31 VA_Width;
`else
typedef 48 VA_Width;
`endif
// Type and function to trim unnecessary fields of a capability that is known to
// be unsealed with the tag set (e.g. PCC)
typedef struct {
  Perms        perms;
  Bit#(FlagsW) flags;
  CBounds      bounds;
  Bit#(VA_Width)     address;
  Bool         validAddress;
} CapTrim deriving(Bits, Eq, FShow);
function CapTrim  trimCap(CapMem cm);
  CapabilityInMemory cap = unpack(cm);
  Bit#(TSub#(CapAddrW,VA_Width)) addr_upper = truncateLSB(cap.address);
  return CapTrim{perms: cap.perms,
                 flags: cap.flags,
                 bounds: cap.bounds,
                 address: truncate(cap.address),
                 validAddress: (addr_upper==signExtend(cap.address[valueOf(VA_Width)-1]))
  };
endfunction
function CapMem untrimCap(CapTrim ct);
  // Encode an invalid address as the bit above the last valid bit being different.
  Bit#(1) addressMsb = ct.address[valueOf(VA_Width)-1];
  if (!ct.validAddress) addressMsb = ^addressMsb;
  return pack(CapabilityInMemory{
                isCapability: True,
                perms: ct.perms,
                reserved: 0,
                flags: ct.flags,
                otype: otype_unsealed,
                bounds: ct.bounds,
                address: signExtend({addressMsb,ct.address})
  });
endfunction

Instances

// "Microarchitectural FShow"
instance FShow#(CapFat);

instance DefaultValue #(Bounds);

instance DefaultValue #(CapFat);

// CapMem CHERICap instance
////////////////////////////////////////////////////////////////////////////////
// Note: commented out methods have a provided default implementation in the
//       CHERICap typeclass definition

instance CHERICap #(CapMem, OTypeW, FlagsW, CapAddrW, CapW, TSub #(MW, 3));

instance FShow #(CapPipe);

// CapReg CHERICap instance
////////////////////////////////////////////////////////////////////////////////
// Note: commented out methods have a provided default implementation in the
//       CHERICap typeclass definition

instance CHERICap #(CapReg, OTypeW, FlagsW, CapAddrW, CapW, TSub #(MW, 3));

instance CHERICap #(CapPipe, OTypeW, FlagsW, CapAddrW, CapW, TSub#(MW, 3));

  //Functions supported by CapReg are just passed through
## Debug trace ### CheriCC_FAT ```bluespec import DefaultValue :: *; import CHERICap :: *; typedef 4 UPermW; typedef 14 MW; typedef 6 ExpW; typedef 18 OTypeW; typedef `FLAGSW FlagsW; typedef 64 CapAddrW; typedef 128 CapW; // The Address type is used to represent the full sized address returned to the // consuming pipeline. In cases where fewer than CapAddrW bits are stored to // represent a memory address (and remaining bits are usable for storing extra // metadata), returning a value of type Address is currently expected to sign // extend the address. // SizeOf#(Address) should be greater or equal to CapAddrW typedef CapAddrW AddressW; typedef Bit#(AddressW) Address; typedef TDiv#(ExpW,2) HalfExpW; typedef TSub#(MW,HalfExpW) UpperMW; // The compressed bounds field type typedef TSub#(TMul#(MW,2),1) CBoundsW; typedef Bit#(CBoundsW) CBounds; // The CapAddr types typedef Bit#(CapAddrW) CapAddr; typedef Bit#(TAdd#(CapAddrW,1)) CapAddrPlus1; typedef Bit#(TAdd#(CapAddrW,2)) CapAddrPlus2; // The Hardware permissions type typedef struct { Bool permit_set_CID; Bool access_sys_regs; Bool permit_unseal; Bool permit_ccall; Bool permit_seal; Bool permit_store_ephemeral_cap; Bool permit_store_cap; Bool permit_load_cap; Bool permit_store; Bool permit_load; Bool permit_execute; Bool non_ephemeral; } HPerms deriving(Bits, Eq, FShow); // 12 bits // The permissions field, including both "soft" and "hard" permission bits. typedef struct { Bit#(UPermW) soft; HPerms hard; } Perms deriving(Bits, Eq, FShow); typedef SizeOf#(Perms) PermsW; // The reserved bits typedef TSub#(CapW, TAdd#( CapAddrW , TAdd#( OTypeW , TAdd#( CBoundsW , TAdd#(PermsW, FlagsW))))) ResW; typedef struct { Bool isCapability; Perms perms; Bit#(ResW) reserved; Bit#(FlagsW) flags; Bit#(OTypeW) otype; CBounds bounds; CapAddr address; } CapabilityInMemory deriving (Bits, Eq, FShow); // CapW + 1 (tag bit) // The full capability structure as Bits, including the "tag" bit. typedef Bit#(TAdd#(CapW,1)) Capability; // not including the tag bit typedef Bit#(CapW) CapBits; // Bit type of the debug capability typedef Bit#(CapW) DebugCap; // Format of the cheri concentrate capability typedef enum {Exp0, EmbeddedExp} Format deriving (Bits, Eq, FShow); // Exponent type typedef UInt#(ExpW) Exp; // Type for capability otype field typedef VnD#(Bit#(OTypeW)) CType; Bit#(OTypeW) otype_max = -5; Bit#(OTypeW) otype_unsealed = -1; Bit#(OTypeW) otype_sentry = -2; Bit#(OTypeW) otype_res0 = -3; Bit#(OTypeW) otype_res1 = -4; // unpacked capability format typedef struct { Bool isCapability; Bit#(CapAddrW) address; Bit#(MW) addrBits; Perms perms; Bit#(FlagsW) flags; Bit#(ResW) reserved; Bit#(OTypeW) otype; Format format; Bounds bounds; } CapFat deriving (Bits); // Exponent that pushes the implied +1 of the top 1 bit outside the address space Exp resetExp = fromInteger(valueOf(TSub#(TAdd#(CapAddrW,2),MW))); Bit#(MW) resetTop = {2'b01,0}; typedef struct { Exp exp; Bit#(MW) topBits; Bit#(MW) baseBits; } Bounds deriving (Bits, Eq, FShow); instance DefaultValue #(Bounds); defaultValue = Bounds { exp : resetExp , topBits : resetTop , baseBits: 0 }; endinstance instance DefaultValue #(CapFat); defaultValue = CapFat { isCapability: True , perms : unpack(~0) , flags : 0 , reserved : 0 , otype : otype_unsealed , format : EmbeddedExp , bounds : defaultValue , address : 0 , addrBits : 0 }; endinstance CapFat null_cap = CapFat { isCapability: False , perms : unpack(0) , flags : 0 , reserved : 0 , otype : otype_unsealed , format : EmbeddedExp , bounds : defaultValue , address : 0 , addrBits : 0 }; /////////////////////////////////////////////// // CHERI CONCENTRATE, example 128-bit format // /////////////////////////////////////////////// // In memory representation // //////////////////////////////////////////////////////////////////////////////// /* XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX Note that the Flags field does not currently appear in the drawing below XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX Embedded Exp 127___124_123_112_111_109_108__91__90_89_________________________78_77__________________________64 | | | | | | | | | uperms | perms | res | otype | 0 | top<11:0>| base<13:0>| Exp0 | uperms | perms | res | | 1 | top<11:3>|e<5:3>| base<13:3>|e<2:0>| EmbeddedExp |________|_______|_______|_______|___|_____________________________|_____________________________| 63_______________________________________________________________________________________________0 | | | address | |________________________________________________________________________________________________| reconstructing most significant top bits: top<20:19> = base<20:19> + carry_out + len_correction where carry_out = 1 if top<18:0> < base <18:0> 0 otherwise len_correction = 0 if Exp0 1 otherwise */ // These three bounds formats help with the decBounds function. typedef struct { Bool embeddedExp; Bit#(TSub#(MW,2)) top; Bit#(MW) base; } BoundsExp0 deriving(Bits, Eq, FShow); typedef struct { Bool embeddedExp; Bit#(TSub#(MW,TAdd#(HalfExpW,2))) topUpperBits; Bit#(HalfExpW) expTopHalf; Bit#(TSub#(MW,HalfExpW)) baseUpperBits; Bit#(HalfExpW) expBotHalf; } BoundsEmbeddedExp deriving(Bits, Eq, FShow); typedef struct { Bit#(3) repBoundTopBits; Bool topHi; Bool baseHi; Bool addrHi; Int#(2) topCorrection; Int#(2) baseCorrection; } MetaInfo deriving(Bits, Eq, FShow); ``` ### Function shapes ``` 1. function Fmt showArchitectural(CapFat cap) 2. instance FShow#(CapFat); function Fmt fshow(CapFat cap) 3. // unpack a memory representation of the capability function CapFat unpackCap(Capability thin); 4. // pack the fat capability into the memory representation function Capability packCap(CapFat fat); 5. // Interface functions //------------------------------------------------------------------------------ function BoundsInfo#(CapAddrW) getBoundsInfoFat (CapFat cap, TempFields tf) 6. function CapAddr getBotFat(CapFat cap, TempFields tf); 7. function CapAddrPlus1 getTopFat(CapFat cap, TempFields tf); function CapAddr getLengthFat(CapFat cap, TempFields tf); function Address getOffsetFat(CapFat cap, TempFields tf); function CapFat setCapPointer(CapFat cap, CapAddr pointer); function Bit#(n) smearMSBRight(Bit#(n) x); function SetBoundsReturn#(CapFat, CapAddrW) setBoundsFat(CapFat cap, Address lengthFull, TempFields tf); function CapFat seal(CapFat cap, TempFields tf, CType otype); function CapFat unseal(CapFat cap, x _); function VnD#(CapFat) incOffsetFat( CapFat cap , CapAddr pointer , CapAddr offset // this is the increment in inc offset, and the offset in set offset , TempFields tf , Bool setOffset); function VnD#(CapFat) setAddress(CapFat cap, CapAddr address, TempFields tf); function Tuple2#(Format, Bounds) decBounds (CBounds raw); function CBounds encBounds (Format format, Bounds bounds); function MetaInfo getMetaInfo (CapFat cap); instance CHERICap #(CapMem, OTypeW, FlagsW, CapAddrW, CapW, TSub #(MW, 3)); function isValidCap (capMem); function getFlags (capMem); function setFlags (capMem, f); function getHardPerms (capMem); // capability in-memory architectural representation ////////////////////////////////////////////////////////////////////////////// function getMeta (capMem); function getAddr (capMem); function fromMem(x) = unpack(pack(x)); function toMem(x) = unpack(pack(x)); function setAddrUnsafe (capMem, address); function addAddrUnsafe (capMem, inc) // CapReg CHERICap instance //////////////////////////////////////////////////////////////////////////////// // Note: commented out methods have a provided default implementation in the // CHERICap typeclass definition instance CHERICap #(CapReg, OTypeW, FlagsW, CapAddrW, CapW, TSub #(MW, 3)); function isValidCap (x) = x.isCapability; function setValidCap (cap, tag); function setValidCap (cap, tag); function setFlags (cap, flags); function getHardPerms (cap) function setHardPerms (cap, perms) function getSoftPerms (cap) = zeroExtend (cap.perms.soft); function setSoftPerms (cap, perms); function getKind (cap) = case (cap.otype) function setKind (cap, kind) function validAsType (dummy, checkType) // capability in-memory architectural representation ////////////////////////////////////////////////////////////////////////////// function getMeta (capReg) function getAddr (capReg) function fromMem (x) function toMem (x) function isDerivable (cap) instance CHERICap #(CapPipe, OTypeW, FlagsW, CapAddrW, CapW, TSub#(MW, 3)); //Functions supported by CapReg are just passed through typedef 31 VA_Width; `else typedef 48 VA_Width; `endif // Type and function to trim unnecessary fields of a capability that is known to // be unsealed with the tag set (e.g. PCC) typedef struct { Perms perms; Bit#(FlagsW) flags; CBounds bounds; Bit#(VA_Width) address; Bool validAddress; } CapTrim deriving(Bits, Eq, FShow); function CapTrim trimCap(CapMem cm); CapabilityInMemory cap = unpack(cm); Bit#(TSub#(CapAddrW,VA_Width)) addr_upper = truncateLSB(cap.address); return CapTrim{perms: cap.perms, flags: cap.flags, bounds: cap.bounds, address: truncate(cap.address), validAddress: (addr_upper==signExtend(cap.address[valueOf(VA_Width)-1])) }; endfunction function CapMem untrimCap(CapTrim ct); // Encode an invalid address as the bit above the last valid bit being different. Bit#(1) addressMsb = ct.address[valueOf(VA_Width)-1]; if (!ct.validAddress) addressMsb = ^addressMsb; return pack(CapabilityInMemory{ isCapability: True, perms: ct.perms, reserved: 0, flags: ct.flags, otype: otype_unsealed, bounds: ct.bounds, address: signExtend({addressMsb,ct.address}) }); endfunction ``` ## Instances ```bluespec // "Microarchitectural FShow" instance FShow#(CapFat); instance DefaultValue #(Bounds); instance DefaultValue #(CapFat); // CapMem CHERICap instance //////////////////////////////////////////////////////////////////////////////// // Note: commented out methods have a provided default implementation in the // CHERICap typeclass definition instance CHERICap #(CapMem, OTypeW, FlagsW, CapAddrW, CapW, TSub #(MW, 3)); instance FShow #(CapPipe); // CapReg CHERICap instance //////////////////////////////////////////////////////////////////////////////// // Note: commented out methods have a provided default implementation in the // CHERICap typeclass definition instance CHERICap #(CapReg, OTypeW, FlagsW, CapAddrW, CapW, TSub #(MW, 3)); instance CHERICap #(CapPipe, OTypeW, FlagsW, CapAddrW, CapW, TSub#(MW, 3)); //Functions supported by CapReg are just passed through ```
me commented 2026-03-13 13:30:47 +00:00
Author
Owner
Copy Link

Used 25 bits between pointer instead to extract delta value.

Used 25 bits between pointer instead to extract delta value.
me closed this issue 2026-03-13 13:30:54 +00:00
Sign in to join this conversation.
No Branch/Tag Specified
Branches Tags
Labels
No items
No Label
Milestone
No items
No Milestone
Projects
Clear projects
No project FAT alloc with RISCV
Assignees
Clear assignees
me
No Assignees me
1 Participants
Notifications
Due Date
No due date set.
Dependencies

No dependencies set.

Reference: Cheri-research/cheri-cap-lib#2
Delete Branch "%!s()"

Deleting a branch is permanent. Although the deleted branch may continue to exist for a short time before it actually gets removed, it CANNOT be undone in most cases. Continue?