/*
* Initializes a MPI.
*
* A temporary MPI is allocated and if a bigInt is supplied the MPI is
* initialized with the value of the bigInt.
*/
static void get_mpi(mbedtls_mpi *mpi, const TEE_BigInt *bigInt)
{
/*
* The way the GP spec is defining the bignums it's
* difficult/tricky to do it using 64-bit arithmetics given that
* we'd need 64-bit alignment of the data as well.
*/
COMPILE_TIME_ASSERT(sizeof(mbedtls_mpi_uint) == sizeof(uint32_t));
/*
* The struct bigint_hdr is the overhead added to the bigint and
* is required to take exactly 2 uint32_t.
*/
COMPILE_TIME_ASSERT(sizeof(struct bigint_hdr) ==
sizeof(uint32_t) * BIGINT_HDR_SIZE_IN_U32);
mbedtls_mpi_init_mempool(mpi);
if (bigInt) {
const struct bigint_hdr *hdr = (struct bigint_hdr *)bigInt;
const mbedtls_mpi_uint *p = (const mbedtls_mpi_uint *)(hdr + 1);
size_t n = hdr->nblimbs;
/* Trim of eventual insignificant zeroes */
while (n && !p[n - 1])
n--;
MPI_CHECK(mbedtls_mpi_grow(mpi, n));
mpi->s = hdr->sign;
memcpy(mpi->p, p, n * sizeof(mbedtls_mpi_uint));
}
}
typename xtl::TypeTraits<T>::LengthType Sqrt(const T& a)
{
typedef typename xtl::TypeTraits<T>::LengthType LengthType;
COMPILE_TIME_ASSERT(xtl::TypeTraits<T>::IsArithmetic);
COMPILE_TIME_ASSERT(xtl::TypeTraits<LengthType>::IsReal);
return sqrt(xtl::RealCast<LengthType>(a));
}
void CSocketAddress::ApplyStunXorMap(const StunTransactionId& transid)
{
const size_t iplen = (_address.addr.sa_family == AF_INET) ? STUN_IPV4_LENGTH : STUN_IPV6_LENGTH;
uint8_t* pPort;
uint8_t* pIP;
if (_address.addr.sa_family == AF_INET)
{
COMPILE_TIME_ASSERT(sizeof(_address.addr4.sin_addr) == STUN_IPV4_LENGTH); // 4
COMPILE_TIME_ASSERT(sizeof(_address.addr4.sin_port) == 2);
pPort = (uint8_t*)&(_address.addr4.sin_port);
pIP = (uint8_t*)&(_address.addr4.sin_addr);
}
else
{
COMPILE_TIME_ASSERT(sizeof(_address.addr6.sin6_addr) == STUN_IPV6_LENGTH); // 16
COMPILE_TIME_ASSERT(sizeof(_address.addr6.sin6_port) == 2);
pPort = (uint8_t*)&(_address.addr6.sin6_port);
pIP = (uint8_t*)&(_address.addr6.sin6_addr);
}
pPort[0] = pPort[0] ^ transid.id[0];
pPort[1] = pPort[1] ^ transid.id[1];
for (size_t i = 0; i < iplen; i++)
{
pIP[i] = pIP[i] ^ transid.id[i];
}
}
PackUnix::PackUnix(InputFile *f) :
super(f), exetype(0), blocksize(0), overlay_offset(0), lsize(0)
{
COMPILE_TIME_ASSERT(sizeof(Elf32_Ehdr) == 52);
COMPILE_TIME_ASSERT(sizeof(Elf32_Phdr) == 32);
COMPILE_TIME_ASSERT(sizeof(b_info) == 12);
COMPILE_TIME_ASSERT(sizeof(l_info) == 12);
COMPILE_TIME_ASSERT(sizeof(p_info) == 12);
}
/*
* Called once (from main) to initialize STM infrastructure.
*/
_CALLCONV void
stm_init(void)
{
#if CM == CM_MODULAR
char *s;
#endif /* CM == CM_MODULAR */
#ifdef SIGNAL_HANDLER
struct sigaction act;
#endif /* SIGNAL_HANDLER */
PRINT_DEBUG("==> stm_init()\n");
if (_tinystm.initialized)
return;
PRINT_DEBUG("\tsizeof(word)=%d\n", (int)sizeof(stm_word_t));
PRINT_DEBUG("\tVERSION_MAX=0x%lx\n", (unsigned long)VERSION_MAX);
COMPILE_TIME_ASSERT(sizeof(stm_word_t) == sizeof(void *));
COMPILE_TIME_ASSERT(sizeof(stm_word_t) == sizeof(atomic_t));
#ifdef EPOCH_GC
gc_init(stm_get_clock);
#endif /* EPOCH_GC */
#if CM == CM_MODULAR
s = getenv(VR_THRESHOLD);
if (s != NULL)
_tinystm.vr_threshold = (int)strtol(s, NULL, 10);
else
_tinystm.vr_threshold = VR_THRESHOLD_DEFAULT;
PRINT_DEBUG("\tVR_THRESHOLD=%d\n", _tinystm.vr_threshold);
#endif /* CM == CM_MODULAR */
/* Set locks and clock but should be already to 0 */
memset((void *)_tinystm.locks, 0, LOCK_ARRAY_SIZE * sizeof(stm_word_t));
CLOCK = 0;
stm_quiesce_init();
tls_init();
#ifdef SIGNAL_HANDLER
if (getenv(NO_SIGNAL_HANDLER) == NULL) {
/* Catch signals for non-faulting load */
act.sa_handler = signal_catcher;
act.sa_flags = 0;
sigemptyset(&act.sa_mask);
if (sigaction(SIGBUS, &act, NULL) < 0 || sigaction(SIGSEGV, &act, NULL) < 0) {
perror("sigaction");
exit(1);
}
}
#endif /* SIGNAL_HANDLER */
_tinystm.initialized = 1;
}
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CObjectBuffStation::CObjectBuffStation()
{
// Verify networking data.
COMPILE_TIME_ASSERT( BUFF_STATION_MAX_PLAYERS < ( 1 << BUFF_STATION_MAX_PLAYER_BITS ) );
COMPILE_TIME_ASSERT( BUFF_STATION_MAX_PLAYERS >= ( 1 << ( BUFF_STATION_MAX_PLAYER_BITS - 1 ) ) );
COMPILE_TIME_ASSERT( BUFF_STATION_MAX_OBJECTS < ( 1 << BUFF_STATION_MAX_OBJECT_BITS ) );
COMPILE_TIME_ASSERT( BUFF_STATION_MAX_OBJECTS >= ( 1 << ( BUFF_STATION_MAX_OBJECT_BITS - 1 ) ) );
// Uses the client-side animation system.
UseClientSideAnimation();
}
static void sanity_checks()
{
COMPILE_TIME_ASSERT(sizeof(convert_64_t) == 8);
COMPILE_TIME_ASSERT(sizeof(convert_32_t) == 4);
COMPILE_TIME_ASSERT(sizeof(stm_word_t) == 4 || sizeof(stm_word_t) == 8);
COMPILE_TIME_ASSERT(sizeof(char) == 1);
COMPILE_TIME_ASSERT(sizeof(short) == 2);
COMPILE_TIME_ASSERT(sizeof(int) == 4);
COMPILE_TIME_ASSERT(sizeof(long) == 4 || sizeof(long) == 8);
COMPILE_TIME_ASSERT(sizeof(float) == 4);
COMPILE_TIME_ASSERT(sizeof(double) == 8);
}
XmlNodeRef CScoreIncEvent::GetXML(IGameStatistics* pGS)
{
XmlNodeRef node = pGS->CreateStatXMLNode();
node->setAttr("score", m_score);
COMPILE_TIME_ASSERT(EGRST_Num==ARRAY_COUNT(k_ScoreIncTypeStrs));
EGameRulesScoreType type=m_type;
const char *pStr = "Unknown";
if (m_type>=0 && m_type<ARRAY_COUNT(k_ScoreIncTypeStrs))
{
pStr = k_ScoreIncTypeStrs[m_type];
}
// skip code prefixes from enums to make them more human readable
if (strncmp(pStr,"EGRST_",6)==0)
{
pStr+=6;
}
node->setAttr("type", pStr);
return node;
}
XmlNodeRef CXPIncEvent::GetXML(IGameStatistics* pGS)
{
XmlNodeRef node = pGS->CreateStatXMLNode();
node->setAttr("delta", m_delta);
COMPILE_TIME_ASSERT(k_XPRsn_Num==ARRAY_COUNT(k_XPIncRsnsStrs));
EXPReason reason=m_reason;
if (reason<0 || reason>=ARRAY_COUNT(k_XPIncRsnsStrs))
{
reason=k_XPRsn_Unknown;
}
const char *pStr=k_XPIncRsnsStrs[reason];
// skip code prefixes from enums to make them more human readable
if (strncmp(pStr,"EPP_",4)==0)
{
pStr+=4;
}
else if (strncmp(pStr,"EGRST_",6)==0)
{
pStr+=6;
}
else if (strncmp(pStr,"k_XPRsn_",8)==0)
{
pStr+=8;
}
node->setAttr("reason", pStr);
return node;
}
typename xtl::TypeTraits<T>::AccumType Square(const T& a)
{
COMPILE_TIME_ASSERT(xtl::TypeTraits<T>::IsArithmetic);
typedef typename xtl::TypeTraits<T>::AccumType AccumType;
AccumType b = xtl::RealCast<AccumType>(a);
return b * b;
}
PackVmlinuzI386::PackVmlinuzI386(InputFile *f) :
super(f), physical_start(0x100000), page_offset(0), config_physical_align(0)
, filter_len(0)
{
bele = &N_BELE_RTP::le_policy;
COMPILE_TIME_ASSERT(sizeof(boot_sect_t) == 0x250);
}
HRESULT CSocketAddress::GetLocalHost(uint16_t family, CSocketAddress* pAddr)
{
if ( ((family != AF_INET) && (family != AF_INET6)) ||
(pAddr == NULL))
{
ASSERT(false);
return E_FAIL;
}
if (family == AF_INET)
{
uint32_t ip = 0x7f000001; // 127.0.0.1 in host byte order
*pAddr = CSocketAddress(ip, 0);
}
else
{
sockaddr_in6 addr6 = {};
COMPILE_TIME_ASSERT(sizeof(addr6.sin6_addr) == 16);
// ::1
uint8_t ip6[16] = {};
ip6[15] = 1;
addr6.sin6_family = AF_INET6;
memcpy(&addr6.sin6_addr, ip6, 16);
*pAddr = CSocketAddress(addr6);
}
return S_OK;
}
BOOL Identify(HANDLE hPhysical)
{
ATA_PASSTHROUGH_CMD Command = {0};
IDENTIFY_DEVICE_DATA* idd;
int i, r;
Command.AtaCmd = ATA_IDENTIFY_DEVICE;
// You'll get an error here if your compiler does not properly pack the IDENTIFY struct
COMPILE_TIME_ASSERT(sizeof(IDENTIFY_DEVICE_DATA) == 512);
idd = (IDENTIFY_DEVICE_DATA*)_mm_malloc(sizeof(IDENTIFY_DEVICE_DATA), 0x10);
if (idd == NULL)
return FALSE;
for (i=0; i<ARRAYSIZE(pt); i++) {
r = pt[i].fn(hPhysical, &Command, idd, sizeof(IDENTIFY_DEVICE_DATA), SPT_TIMEOUT_VALUE);
if (r == SPT_SUCCESS) {
uprintf("Success using %s\n", pt[i].type);
if (idd->CommandSetSupport.SmartCommands) {
DumpBufferHex(idd, sizeof(IDENTIFY_DEVICE_DATA));
uprintf("SMART support detected!\n");
} else {
uprintf("No SMART support\n");
}
break;
}
uprintf("No joy with: %s (%s)\n", pt[i].type, SptStrerr(r));
}
if (i >= ARRAYSIZE(pt))
uprintf("NO ATA FOR YOU!\n");
_mm_free(idd);
return TRUE;
}
static void *raw_malloc(size_t hdr_size, size_t ftr_size, size_t pl_size)
{
void *ptr = NULL;
size_t s = hdr_size + ftr_size + pl_size;
/*
* Make sure that malloc has correct alignment of returned buffers.
* The assumption is that uintptr_t will be as wide as the largest
* required alignment of any type.
*/
COMPILE_TIME_ASSERT(SizeQuant >= sizeof(uintptr_t));
raw_malloc_validate_pools();
/* Check wrapping */
if (s < pl_size)
goto out;
/* BGET doesn't like 0 sized allocations */
if (!s)
s++;
ptr = bget(s);
out:
raw_malloc_return_hook(ptr, pl_size);
return ptr;
}
struct grub_net_buff *
grub_netbuff_alloc (grub_size_t len)
{
struct grub_net_buff *nb;
void *data;
COMPILE_TIME_ASSERT (NETBUFF_ALIGN % sizeof (grub_properly_aligned_t) == 0);
if (len < NETBUFFMINLEN)
len = NETBUFFMINLEN;
len = ALIGN_UP (len, NETBUFF_ALIGN);
#ifdef GRUB_MACHINE_EMU
data = grub_malloc (len + sizeof (*nb));
#else
data = grub_memalign (NETBUFF_ALIGN, len + sizeof (*nb));
#endif
if (!data)
return NULL;
nb = (struct grub_net_buff *) ((grub_properly_aligned_t *) data
+ len / sizeof (grub_properly_aligned_t));
nb->head = nb->data = nb->tail = data;
nb->end = (grub_uint8_t *) nb;
return nb;
}
uint32_t
_cairo_xcb_connection_shm_attach (cairo_xcb_connection_t *connection,
uint32_t id,
cairo_bool_t readonly)
{
struct {
uint8_t req;
uint8_t shm_req;
uint16_t length;
uint32_t segment;
uint32_t id;
uint8_t readonly;
uint8_t pad1;
uint16_t pad2;
} req;
struct iovec vec[1];
COMPILE_TIME_ASSERT (sizeof (req) == 16);
req.req = connection->shm->major_opcode;
req.shm_req = 1;
req.length = sizeof (req) >> 2;
req.segment = _cairo_xcb_connection_get_xid (connection);
req.id = id;
req.readonly = readonly;
vec[0].iov_base = &req;
vec[0].iov_len = sizeof (req);
_cairo_xcb_connection_write (connection, vec, 1);
return req.segment;
}
//-----------------------------------------------------------------------------
// Gets at the nth item in the list
//-----------------------------------------------------------------------------
TrailPoint_t *CSpriteTrail::GetTrailPoint( int n )
{
Assert( n < MAX_SPRITE_TRAIL_POINTS );
COMPILE_TIME_ASSERT( (MAX_SPRITE_TRAIL_POINTS & (MAX_SPRITE_TRAIL_POINTS-1)) == 0 );
int nIndex = (n + m_nFirstStep) & MAX_SPRITE_TRAIL_MASK;
return &m_vecSteps[nIndex];
}
void
_cairo_xcb_connection_shm_detach (cairo_xcb_connection_t *connection,
uint32_t segment)
{
struct {
uint8_t req;
uint8_t shm_req;
uint16_t length;
uint32_t segment;
} req;
struct iovec vec[1];
COMPILE_TIME_ASSERT (sizeof (req) == 8);
req.req = connection->shm->major_opcode;
req.shm_req = 2;
req.length = sizeof (req) >> 2;
req.segment = segment;
vec[0].iov_base = &req;
vec[0].iov_len = sizeof (req);
_cairo_xcb_connection_write (connection, vec, 1);
_cairo_xcb_connection_put_xid (connection, segment);
}
virtual void GetConfiguration( SFlowNodeConfig& config )
{
COMPILE_TIME_ASSERT( PORT_NONE + 1 == 0 ); // or else the automatic boundary checks when incrememting the port number would not work
static const SInputPortConfig in_config[] = {
InputPortConfig_AnyType("In", _HELP("Input")),
InputPortConfig<bool> ( "Closed", false, _HELP("If true blocks all signals.")),
InputPortConfig_Void ( "Open", _HELP("Sets [Closed] to false.")),
InputPortConfig_Void ( "Close", _HELP("Sets [Closed] to true.")),
InputPortConfig_Void ("Reset", _HELP("Forces next output to be Port1 again")),
InputPortConfig<bool> ( "Reverse", false, _HELP("If true, the order of output activation is reversed.")),
{0}
};
static const SOutputPortConfig out_config[] = {
OutputPortConfig_AnyType("Out1", _HELP("Output1")),
OutputPortConfig_AnyType("Out2", _HELP("Output2")),
OutputPortConfig_AnyType("Out3", _HELP("Output3")),
OutputPortConfig_AnyType("Out4", _HELP("Output4")),
OutputPortConfig_AnyType("Out5", _HELP("Output5")),
OutputPortConfig_AnyType("Out6", _HELP("Output6")),
OutputPortConfig_AnyType("Out7", _HELP("Output7")),
OutputPortConfig_AnyType("Out8", _HELP("Output8")),
OutputPortConfig_AnyType("Out9", _HELP("Output9")),
OutputPortConfig_AnyType("Out10", _HELP("Output10")),
{0}
};
config.sDescription = _HELP("On each [In] trigger, triggers one of the connected outputs in sequential order.");
config.pInputPorts = in_config;
config.pOutputPorts = out_config;
config.nFlags |= EFLN_AISEQUENCE_SUPPORTED;
config.SetCategory(EFLN_APPROVED);
}
const cascade_t &GetCascadeInfo( int index )
{
Assert( index >= 0 && index < iNumCascades );
COMPILE_TIME_ASSERT( iNumCascades == SHADOW_NUM_CASCADES );
return g_CascadeInfo[ index ];
}
void tee_svc_handler(struct thread_svc_regs *regs)
{
size_t scn;
size_t max_args;
syscall_t scf;
COMPILE_TIME_ASSERT(ARRAY_SIZE(tee_svc_syscall_table) ==
(TEE_SCN_MAX + 1));
/* Restore IRQ which are disabled on exception entry */
thread_restore_irq();
thread_disable_concurrency();
get_scn_max_args(regs, &scn, &max_args);
#if (TRACE_LEVEL == TRACE_FLOW) && defined(CFG_TEE_CORE_TA_TRACE)
tee_svc_trace_syscall(scn);
#endif
if (max_args > TEE_SVC_MAX_ARGS) {
DMSG("Too many arguments for SCN %zu (%zu)", scn, max_args);
set_svc_retval(regs, TEE_ERROR_GENERIC);
return;
}
if (scn > TEE_SCN_MAX)
scf = syscall_nocall;
else
scf = tee_svc_syscall_table[scn];
set_svc_retval(regs, tee_svc_do_call(regs, scf));
thread_enable_concurrency();
}
/*
* Initialize PL061 GPIO controller
*/
void pl061_init(struct pl061_data *pd)
{
COMPILE_TIME_ASSERT(PLAT_PL061_MAX_GPIOS > 0);
assert(pd);
pd->chip.ops = &pl061_ops;
}
inline Registers_ppc::Registers_ppc(const void* registers)
{
COMPILE_TIME_ASSERT( sizeof(Registers_ppc) < sizeof(unw_context_t) );
fRegisters = *((ppc_thread_state_t*)registers);
fFloatRegisters = *((ppc_float_state_t*)((char*)registers+160));
memcpy(fVectorRegisters, ((char*)registers+424), sizeof(fVectorRegisters));
}
void CSoundParametersInternal::AddToTail( SoundFile **pDest, uint16 *pDestCount, const SoundFile &source )
{
(*pDestCount)++;
if ( *pDestCount == 1 )
{
// NOTE: when there's only one soundfile in the list, we store it
// packed into the pointer itself, the four bytes for the pointer is just used to store the sound file!
COMPILE_TIME_ASSERT( sizeof(SoundFile) <= sizeof(SoundFile *) );
*((SoundFile *)(pDest)) = source;
}
else
{
SoundFile temp;
if ( *pDestCount == 2 )
{
// Copying from a list of one soundfile. Save off the struct
// packed into the pointer field.
temp = *((SoundFile *)(pDest));
*pDest = NULL;
}
*pDest = (SoundFile *)realloc( *pDest, (*pDestCount) * sizeof(SoundFile) );
(*pDest)[ *pDestCount - 1 ] = source;
if ( *pDestCount == 2 )
{
(*pDest)[0] = temp;
}
}
}
void mpf_manager::set(mpf & o, unsigned ebits, unsigned sbits, int value) {
COMPILE_TIME_ASSERT(sizeof(int) == 4);
o.sign = false;
o.ebits = ebits;
o.sbits = sbits;
TRACE("mpf_dbg", tout << "set: value = " << value << std::endl;);
static inline grub_uint32_t
grub_nilfs2_palloc_log_groups_per_desc_block (struct grub_nilfs2_data *data)
{
return LOG2_BLOCK_SIZE (data) - LOG_SIZE_GROUP_DESC;
COMPILE_TIME_ASSERT (sizeof (struct grub_nilfs2_palloc_group_desc)
== (1 << LOG_SIZE_GROUP_DESC));
}
const char *GetWeaponProficiencyName( WeaponProficiency_t proficiency )
{
COMPILE_TIME_ASSERT( ARRAYSIZE(g_ProficiencyNames) == WEAPON_PROFICIENCY_PERFECT + 1 ); // Hey, update that there table!
if ( proficiency < 0 || proficiency > WEAPON_PROFICIENCY_PERFECT )
return "<<Invalid>>";
return g_ProficiencyNames[proficiency];
}
int upx_ucl_compress ( const upx_bytep src, unsigned src_len,
upx_bytep dst, unsigned* dst_len,
upx_callback_p cb_parm,
int method, int level,
const upx_compress_config_t *cconf_parm,
upx_compress_result_t *cresult )
{
int r;
assert(level > 0); assert(cresult != NULL);
COMPILE_TIME_ASSERT(sizeof(ucl_compress_config_t) == sizeof(REAL_ucl_compress_config_t))
ucl_progress_callback_t cb;
cb.callback = 0;
cb.user = NULL;
if (cb_parm && cb_parm->nprogress) {
cb.callback = wrap_nprogress_ucl;
cb.user = cb_parm;
}
ucl_compress_config_t cconf; cconf.reset();
if (cconf_parm)
memcpy(&cconf, &cconf_parm->conf_ucl, sizeof(cconf)); // cconf = cconf_parm->conf_ucl; // struct copy
ucl_uint *res = cresult->result_ucl.result;
// assume no info available - fill in worst case results
//res[0] = 1; // min_offset_found - NOT USED
res[1] = src_len - 1; // max_offset_found
//res[2] = 2; // min_match_found - NOT USED
res[3] = src_len - 1; // max_match_found
//res[4] = 1; // min_run_found - NOT USED
res[5] = src_len; // max_run_found
res[6] = 1; // first_offset_found
//res[7] = 999999; // same_match_offsets_found - NOT USED
// prepare bit-buffer settings
cconf.bb_endian = 0;
cconf.bb_size = 0;
if (method >= M_NRV2B_LE32 && method <= M_NRV2E_LE16)
{
static const unsigned char sizes[3] = {32, 8, 16};
cconf.bb_size = sizes[(method - M_NRV2B_LE32) % 3];
}
else {
throwInternalError("unknown compression method");
return UPX_E_ERROR;
}
// optimize compression parms
if (level <= 3 && cconf.max_offset == UCL_UINT_MAX)
cconf.max_offset = 8*1024-1;
else if (level == 4 && cconf.max_offset == UCL_UINT_MAX)
cconf.max_offset = 32*1024-1;
if M_IS_NRV2B(method)
r = ucl_nrv2b_99_compress(src, src_len, dst, dst_len,
&cb, level, &cconf, res);
else if M_IS_NRV2D(method)
static uint32_t desc_to_mattr(uint64_t desc)
{
uint32_t a;
if (!(desc & 1)) {
if (desc & HIDDEN_DESC)
return TEE_MATTR_HIDDEN_BLOCK;
if (desc & PHYSPAGE_DESC)
return TEE_MATTR_PHYS_BLOCK;
return 0;
}
a = TEE_MATTR_VALID_BLOCK;
if (desc & LOWER_ATTRS(ACCESS_FLAG))
a |= TEE_MATTR_PRX | TEE_MATTR_URX;
if (!(desc & LOWER_ATTRS(AP_RO)))
a |= TEE_MATTR_PW | TEE_MATTR_UW;
if (!(desc & LOWER_ATTRS(AP_UNPRIV)))
a &= ~TEE_MATTR_URWX;
if (desc & UPPER_ATTRS(XN))
a &= ~(TEE_MATTR_PX | TEE_MATTR_UX);
if (desc & UPPER_ATTRS(PXN))
a &= ~TEE_MATTR_PX;
COMPILE_TIME_ASSERT(ATTR_DEVICE_INDEX == TEE_MATTR_CACHE_NONCACHE);
COMPILE_TIME_ASSERT(ATTR_IWBWA_OWBWA_NTR_INDEX ==
TEE_MATTR_CACHE_CACHED);
a |= ((desc & LOWER_ATTRS(ATTR_INDEX_MASK)) >> LOWER_ATTRS_SHIFT) <<
TEE_MATTR_CACHE_SHIFT;
if (!(desc & LOWER_ATTRS(NON_GLOBAL)))
a |= TEE_MATTR_GLOBAL;
if (!(desc & LOWER_ATTRS(NS)))
a |= TEE_MATTR_SECURE;
return a;
}
int main(int argc, char** argv, char** envp) {
COMPILE_TIME_ASSERT(1==1);
PR_STATIC_ASSERT(1==1);
// this is a built in gcc static assertion, no flags needed
_Static_assert(1==1, "fail message");
ct_assert(1==1);
STATIC_ASSERT(1==1, fail);
// CTC(1==1);
return EXIT_SUCCESS;
}
