Пример #1
0
int main()
{
  printf("a: size = %u, alignment = %u, address mod 16 = %u\n",
         (unsigned) sizeof(a), (unsigned) _Alignof(a), ((unsigned) &a) & 0xF);
  printf("b: size = %u, alignment = %u, address mod 16 = %u\n",
         (unsigned) sizeof(b), (unsigned) _Alignof(b), ((unsigned) &b) & 0xF);
  printf("bb: size = %u, alignment = %u, address mod 16 = %u\n",
         (unsigned) sizeof(bb), (unsigned) _Alignof(bb), ((unsigned) &bb) & 0xF);
#if 0
  printf("bbb: size = %u, alignment = %u, address mod 16 = %u\n",
         (unsigned) sizeof(bbb), (unsigned) _Alignof(bbb), ((unsigned) &bbb) & 0xF);
#endif
  printf("c: size = %u, alignment = %u, address mod 16 = %u\n",
         (unsigned) sizeof(c), (unsigned) _Alignof(c), ((unsigned) &c) & 0xF);
  printf("d: size = %u, alignment = %u, address mod 64 = %u\n",
         (unsigned) sizeof(d), (unsigned) _Alignof(d), ((unsigned) &d) & 0x3F);
  printf("e: size = %u, alignment = %u, address mod 16 = %u\n",
         (unsigned) sizeof(e), (unsigned) _Alignof(e), ((unsigned) &e) & 0xF);
  printf("f: size = %u, alignment = %u, address mod 32 = %u\n",
         (unsigned) sizeof(f), (unsigned) _Alignof(f), ((unsigned) &f) & 0x1F);
  printf("g: size = %u, alignment = %u, address mod 16 = %u\n",
         (unsigned) sizeof(g), (unsigned) _Alignof(g), ((unsigned) &g) & 0xF);
  printf("h: size = %u, alignment = %u, address mod 64 = %u\n",
         (unsigned) sizeof(h), (unsigned) _Alignof(h), ((unsigned) &h) & 0x3F);
  return 0;
}
Пример #2
0
/**
 * Return the native host alignment for values of @p type.
 * 
 * @param type The type to query.
 */
size_t
bhnd_nvram_type_host_align(bhnd_nvram_type type)
{
	switch (type) {
	case BHND_NVRAM_TYPE_CHAR:
	case BHND_NVRAM_TYPE_CHAR_ARRAY:
	case BHND_NVRAM_TYPE_DATA:
	case BHND_NVRAM_TYPE_STRING:
	case BHND_NVRAM_TYPE_STRING_ARRAY:
		return (_Alignof(uint8_t));
	case BHND_NVRAM_TYPE_BOOL:
	case BHND_NVRAM_TYPE_BOOL_ARRAY: {
		_Static_assert(sizeof(bhnd_nvram_bool_t) == sizeof(uint8_t),
		    "bhnd_nvram_bool_t must be uint8-representable");
		return (_Alignof(uint8_t));
	}
	case BHND_NVRAM_TYPE_NULL:
		return (1);
	case BHND_NVRAM_TYPE_UINT8:
	case BHND_NVRAM_TYPE_UINT8_ARRAY:
		return (_Alignof(uint8_t));
	case BHND_NVRAM_TYPE_UINT16:
	case BHND_NVRAM_TYPE_UINT16_ARRAY:
		return (_Alignof(uint16_t));
	case BHND_NVRAM_TYPE_UINT32:
	case BHND_NVRAM_TYPE_UINT32_ARRAY:
		return (_Alignof(uint32_t));
	case BHND_NVRAM_TYPE_UINT64:
	case BHND_NVRAM_TYPE_UINT64_ARRAY:
		return (_Alignof(uint64_t));
	case BHND_NVRAM_TYPE_INT8:
	case BHND_NVRAM_TYPE_INT8_ARRAY:
		return (_Alignof(int8_t));
	case BHND_NVRAM_TYPE_INT16:
	case BHND_NVRAM_TYPE_INT16_ARRAY:
		return (_Alignof(int16_t));
	case BHND_NVRAM_TYPE_INT32:
	case BHND_NVRAM_TYPE_INT32_ARRAY:
		return (_Alignof(int32_t));
	case BHND_NVRAM_TYPE_INT64:
	case BHND_NVRAM_TYPE_INT64_ARRAY:
		return (_Alignof(int64_t));
	}

	/* Quiesce gcc4.2 */
	BHND_NV_PANIC("bhnd nvram type %u unknown", type);
}
Пример #3
0
int
cloudabi32_sys_thread_create(struct thread *td,
    struct cloudabi32_sys_thread_create_args *uap)
{
	struct thread_create_args args;
	int error;

	error = copyin(uap->attr, &args.attr, sizeof(args.attr));
	if (error != 0)
		return (error);

	/* Remove some space on the top of the stack for the TCB. */
	args.tcb = rounddown(args.attr.stack + args.attr.stack_size -
	    sizeof(cloudabi32_tcb_t), _Alignof(cloudabi32_tcb_t));
	args.attr.stack_size = args.tcb - args.attr.stack;

	error = thread_create(td, NULL, initialize_thread, &args);
	if (error != 0)
		return (error);
	td->td_retval[0] = args.tid;
	return (0);
}
Пример #4
0
/* Test C1X alignment support.  Test invalid code.  */
/* { dg-do compile } */
/* { dg-options "-std=c1x -pedantic-errors" } */

int a = _Alignof (void (void)); /* { dg-error "function" } */
struct s;
int b = _Alignof (struct s); /* { dg-error "incomplete" } */
int c = _Alignof (void); /* { dg-error "void" } */
int d = _Alignof (a); /* { dg-error "expression" } */

_Alignas (void (void)) char e; /* { dg-error "function" } */
_Alignas (struct s) char f; /* { dg-error "incomplete" } */
_Alignas (void) char g; /* { dg-error "void" } */

_Alignas (-__INT_MAX__-1) char h; /* { dg-error "too large|power of 2" } */
_Alignas (-__INT_MAX__) char h2; /* { dg-error "too large|power of 2" } */
_Alignas ((-__INT_MAX__-1)/2) char h3; /* { dg-error "too large|power of 2" } */
_Alignas ((-__INT_MAX__-1)/4) char h4; /* { dg-error "too large|power of 2" } */
_Alignas ((-__INT_MAX__-1)/8) char h5; /* { dg-error "too large|power of 2" } */
_Alignas (-__LONG_LONG_MAX__-1) char i; /* { dg-error "too large|power of 2" } */
_Alignas (-(__LONG_LONG_MAX__-1)/2) char i2; /* { dg-error "too large|power of 2" } */
_Alignas (-(__LONG_LONG_MAX__-1)/4) char i3; /* { dg-error "too large|power of 2" } */
_Alignas (-(__LONG_LONG_MAX__-1)/8) char i4; /* { dg-error "too large|power of 2" } */
_Alignas (-(__LONG_LONG_MAX__-1)/16) char i5; /* { dg-error "too large|power of 2" } */
_Alignas (-1) char j; /* { dg-error "power of 2" } */
_Alignas (3) char k; /* { dg-error "power of 2" } */

_Alignas ((void *) 1) char k; /* { dg-error "integer constant" } */
int x;
_Alignas (x) char l; /* { dg-error "integer constant" } */
Пример #5
0
// RUNNOT: %clang_cc1 -fsyntax-only -verify %s -DALIGNOF -DOMITTEDOPERAND -Wgnu-conditional-omitted-operand
// RUNNOT: %clang_cc1 -fsyntax-only -verify %s -DALIGNOF -DEMPTYINIT -Wgnu-empty-initializer
// RUNNOT: %clang_cc1 -fsyntax-only -verify %s -DALIGNOF -DLABELVALUE -Wgnu-label-as-value
// RUNNOT: %clang_cc1 -fsyntax-only -verify %s -DALIGNOF -DSTATEMENTEXP -Wgnu-statement-expression

#if NONE
// expected-no-diagnostics
#endif


#if ALL || ALIGNOF
// expected-warning@+4 {{'_Alignof' applied to an expression is a GNU extension}}
#endif

char align;
_Static_assert(_Alignof(align) > 0, "align's alignment is wrong");


#if ALL || CASERANGE
// expected-warning@+5 {{use of GNU case range extension}}
#endif

void caserange(int x) {
  switch (x) {
  case 42 ... 44: ;
  }
}


#if ALL || COMPLEXINT
// expected-warning@+3 {{complex integer types are a GNU extension}}
Пример #6
0
static int do_multiple_queries(bool do_update, bool use_cache, h2o_req_t *req)
{
	thread_context_t * const ctx = H2O_STRUCT_FROM_MEMBER(thread_context_t,
	                                                      event_loop.h2o_ctx,
	                                                      req->conn->ctx);

	const size_t num_query = get_query_number(req);

	// MAX_QUERIES is a relatively small number, so assume no overflow in the following
	// arithmetic operations.
	assert(num_query <= MAX_QUERIES);

	size_t base_size = offsetof(multiple_query_ctx_t, res) + num_query * sizeof(query_result_t);

	base_size = ((base_size + _Alignof(query_param_t) - 1) / _Alignof(query_param_t));
	base_size = base_size * _Alignof(query_param_t);

	const size_t num_query_in_progress = MIN(num_query, ctx->config->max_db_conn_num);
	size_t sz = base_size + num_query_in_progress * sizeof(query_param_t);

	if (do_update) {
		const size_t reuse_size = (num_query_in_progress - 1) * sizeof(query_param_t);
		const size_t update_query_len = MAX_UPDATE_QUERY_LEN(num_query);

		if (update_query_len > reuse_size)
			sz += update_query_len - reuse_size;
	}

	multiple_query_ctx_t * const query_ctx = calloc(1, sz);

	if (query_ctx) {
		multiple_query_ctx_t ** const p = h2o_mem_alloc_shared(&req->pool,
		                                                       sizeof(*p),
		                                                       cleanup_multiple_query_request);

		*p = query_ctx;
		query_ctx->ctx = ctx;
		query_ctx->num_query = num_query;
		query_ctx->req = req;
		query_ctx->do_update = do_update;
		query_ctx->use_cache = use_cache;
		query_ctx->query_param = (query_param_t *) ((char *) query_ctx + base_size);
		initialize_ids(num_query, query_ctx->res, &ctx->random_seed);

		if (use_cache) {
			fetch_from_cache(h2o_now(ctx->event_loop.h2o_ctx.loop),
			                 &ctx->global_data->world_cache,
			                 query_ctx);

			if (query_ctx->num_result == query_ctx->num_query) {
				complete_multiple_query(query_ctx);
				return 0;
			}
		}

		query_ctx->num_query_in_progress = MIN(num_query_in_progress,
		                                       query_ctx->num_query - query_ctx->num_result);

		for (size_t i = 0; i < query_ctx->num_query_in_progress; i++) {
			query_ctx->query_param[i].ctx = query_ctx;
			// We need a copy of id because the original may be overwritten
			// by a completed query.
			query_ctx->query_param[i].id = htonl(query_ctx->res[query_ctx->num_result + i].id);
			query_ctx->query_param[i].id_format = 1;
			query_ctx->query_param[i].id_len = sizeof(query_ctx->query_param[i].id);
			query_ctx->query_param[i].id_pointer = (const char *) &query_ctx->query_param[i].id;
			query_ctx->query_param[i].param.command = WORLD_TABLE_NAME;
			query_ctx->query_param[i].param.nParams = 1;
			query_ctx->query_param[i].param.on_error = on_multiple_query_error;
			query_ctx->query_param[i].param.on_result = on_multiple_query_result;
			query_ctx->query_param[i].param.on_timeout = on_multiple_query_timeout;
			query_ctx->query_param[i].param.paramFormats = &query_ctx->query_param[i].id_format;
			query_ctx->query_param[i].param.paramLengths = &query_ctx->query_param[i].id_len;
			query_ctx->query_param[i].param.paramValues = &query_ctx->query_param[i].id_pointer;
			query_ctx->query_param[i].param.flags = IS_PREPARED;
			query_ctx->query_param[i].param.resultFormat = 1;

			if (execute_query(ctx, &query_ctx->query_param[i].param)) {
				query_ctx->num_query_in_progress = i;
				query_ctx->cleanup = true;
				send_service_unavailable_error(DB_REQ_ERROR, req);
				return 0;
			}
		}
	}
	else
		send_error(INTERNAL_SERVER_ERROR, REQ_ERROR, req);

	return 0;
}
Пример #7
0
// RUN: %check %s -Wgnu

int x;
int y = _Alignof(x); // CHECK: warning: _Alignof applied to expression is a GNU extension
int z = _Alignof(int){0}; // CHECK: warning: _Alignof applied to expression is a GNU extension
Пример #8
0
#include <stdint.h>
#include "avl.h"

#ifndef __has_feature
#define __has_feature(x) 0
#endif

#if __STDC_VERSION__ >= 201112L || (__has_feature(c_static_assert) && __has_feature(c_alignof))
_Static_assert(_Alignof(avl_node_t) >= 4, "Incompatible avl_node_t alignment");
#elif __GNUC__
typedef char static_assertion_avl_node_t_alignment[!!(__alignof__(avl_node_t)>4)*2-1];
#else
typedef char static_assertion_avl_node_t_alignment[!!(offsetof(struct {char c;avl_node_t t;}, t)>4)*2-1];
#endif

static int avl_abs(int n) {
    int mask = n >> ((sizeof(int) * 8) - 1);
    return (mask + n) ^ mask;
}

static inline int avl_max(int lhs, int rhs) {
    return lhs > rhs ? lhs : rhs;
}

static inline void avl_set_parent(avl_node_t *node, avl_node_t *parent) {
    node->parent = (uintptr_t)parent | (node->parent & 3);
}

static inline avl_node_t *avl_get_parent(const avl_node_t *const node) {
    return (avl_node_t*)(node->parent & ~3);
}
Пример #9
0
// RUN: %layout_check %s

typedef int _AlignT;
enum {
	_Len = sizeof(int),
	_Align = _Alignof(_AlignT),
};

union U1
{
	unsigned char __data[_Len];
	struct __attribute__((__aligned__((_Align)))) S1 { } __align;
} s1;

union U2
{
	unsigned char __data[_Len];
	_Alignas(_Align) struct S2 { } __align;
} s2;

union U3
{
	unsigned char __data[_Len];
	_Alignas(__alignof(_AlignT)) struct S3 { } __align;
} s3;

union U4
{
	unsigned char __data[_Len];
	_Alignas(_AlignT) struct S4 { } __align;
} s4;