ALIGN
struct icmp *icp = (struct icmp *)ALIGN(packet);
struct icmp *icp = (struct icmp *)ALIGN(packet);
sin = (struct sockaddr_in *)ALIGN(addr);
sin = (struct sockaddr_in *)ALIGN(&ifreq.ifr_addr);
sin = (struct sockaddr_in *)ALIGN(&ifreq.ifr_addr);
sin = (struct sockaddr_in *)ALIGN(&ifreq.ifr_addr);
tp = (struct table *)ALIGN(malloc(sizeof (struct table)));
sin = (struct sockaddr_in *)ALIGN(&rt.rt_gateway);
register struct icmp *icp = (struct icmp *)ALIGN(outpack);
register struct icmp_ra *rap = (struct icmp_ra *)ALIGN(outpack);
ap = (struct icmp_ra_addr *)ALIGN(outpack + packetlen);
ip = (struct ip *)ALIGN(buf);
icp = (struct icmp *)ALIGN(buf + hlen);
icp = (struct icmp *)ALIGN(buf);
struct icmp_ra *rap = (struct icmp_ra *)ALIGN(icp);
if (in_cksum((ushort_t *)ALIGN(buf+hlen), cc)) {
ALIGN(buf + hlen + ICMP_MINLEN +
if (in_cksum((ushort_t *)ALIGN(buf+hlen), cc)) {
exthdr = (exthdr_t *)ALIGN(ext);
- (BKEYDATA_PSIZE(0) + ALIGN(1, 4));
sizeof(size_t) : ALIGN(align, sizeof(size_t));
#define ALIGNP(value, bound) ALIGN((ALIGNTYPE)value, bound)
ALIGN((len) + SSZA(BKEYDATA, data), 4)
ALIGN(sizeof(BOVERFLOW), 4)
ALIGN((len) + SSZA(BINTERNAL, data), 4)
ALIGN(sizeof(RINTERNAL), 4)
((size_t)(sizeof(DB_LOCKREGION) + ALIGN((M * M), LOCK_HASH_ALIGN)))
(ALIGN(LOCK_HEADER_SIZE(M) + \
(N) * ALIGN(sizeof(struct __db_lock), MUTEX_ALIGNMENT) + \
ALIGN((N) * sizeof(DB_LOCKOBJ), sizeof(size_t)) + \
ALIGN(STRING_SIZE(N), sizeof(size_t)))
nentries = ALIGN(nlockers, 32) / 32;
nentries = ALIGN(count, 32) / 32;
nentries = ALIGN(nlockers, 32) / 32;
nentries = ALIGN(nlockers, 32) / 32;
lrp->mem_bytes = ALIGN(STRING_SIZE(lrp->maxlocks), sizeof(size_t));
curaddr += ALIGN(sizeof(struct __db_lock), MUTEX_ALIGNMENT)) {
usedlocks * ALIGN(sizeof(struct __db_lock), MUTEX_ALIGNMENT) +
ALIGN(sizeof(struct __db_lock), MUTEX_ALIGNMENT) / (float)used;
incr / ALIGN(sizeof(struct __db_lock), MUTEX_ALIGNMENT));
newlocks * ALIGN(sizeof(struct __db_lock), MUTEX_ALIGNMENT));
newmem += ALIGN(incr, sizeof(size_t)) - incr;
incr = ALIGN(incr, sizeof(size_t));
incr += ALIGN(oldsize, MUTEX_ALIGNMENT) - oldsize;
curaddr += ALIGN(sizeof(struct __db_lock), MUTEX_ALIGNMENT)) {
% ALIGN(elf)[d->db_data.d_type]) == 0) {
ALIGN(fph->p_vaddr, page_size), page_size);
ALIGN(fph->p_vaddr, fph->p_align) + fph->p_align,
foff = ALIGN(pptr->p_offset, page_size);
addr = (caddr_t)ALIGN(faddr + pptr->p_vaddr, page_size);
p->fts_statp = (struct stat *)ALIGN(p->fts_name + namelen + 2);
char w_a[ALIGN]; /* to force size */
#define CORESIZE (1024*ALIGN)
#define MAX_GETCORE (size_t)(SSIZE_MAX & ~(ALIGN - 1)) /* round down ALIGN */
#define MAX_MALLOC (size_t)(SIZE_MAX - CORESIZE - 3 * ALIGN) /* overflow chk */
ASSERT(WORDSIZE == ALIGN);
if ((((uintptr_t)addr) % ALIGN) != 0)
offset = ALIGN - (uintptr_t)addr % ALIGN;
ASSERT((SIZE(tp) % ALIGN) == 0);
malloc(ALIGN(sizeof (*b)) + struct_size + buffer_size);
b->result = (void *)ALIGN(&b[1]);
ASSERT((statictlssize & (ALIGN - 1)) == 0);
ASSERT((tlsp->tm_stattlsoffset & (ALIGN - 1)) == 0);
ALIGN(fph->p_vaddr, page_size), page_size);
ALIGN(fph->p_vaddr, fph->p_align) + fph->p_align,
foff = ALIGN(pptr->p_offset, page_size);
addr = (caddr_t)ALIGN(faddr + pptr->p_vaddr, page_size);
size = ALIGN(size, MTMALLOC_MIN_ALIGN);
endp_lp = ALIGN((uintptr_t)lp + size_lp, MTMALLOC_MIN_ALIGN);
endp_pv = ALIGN((uintptr_t)pv + size_pv,
endp_nx = ALIGN((uintptr_t)nx + size_nx,
off = (caddr_t)ALIGN(wp->addr + size,
#define CACHELIST_SIZE ALIGN(NUM_CACHES * sizeof (cache_head_t), \
#define OVSZ_SIZE (ALIGN(sizeof (oversize_t), MTMALLOC_MIN_ALIGN))
alloc_size = ALIGN(alloc_size, MTMALLOC_MIN_ALIGN);
taddr = ALIGN((uintptr_t)alloc_buf + size,
taddr = ALIGN((uintptr_t)alloc_buf +
taddr = ALIGN(ret_addr + size,
taddr = ALIGN(ret_addr + size,
newbrk = ALIGN(oldbrk, CACHE_COHERENCY_UNIT);
padding = ALIGN(newbrk, HUNKSIZE) - newbrk;
cp->mt_arena = (caddr_t)ALIGN(cp->mt_freelist + 8, 8);
cp->mt_arena = (caddr_t)ALIGN((caddr_t)cp->mt_freelist +
if ((bufp->result = malloc(ALIGN(sizeof (struct hostent)) + bufsz)) ==
len = (char *)ALIGN(buf) - buf;
ptr = (char **)ALIGN(buf);
cp = (char *)ALIGN(buf) + nptr * sizeof(char *);
len = (char *)ALIGN(buf) - buf;
cp = (char *)ALIGN(buf) + numptr * sizeof(char *);
nptr->n_aliases = (char **)ALIGN(buf);
len = (char *)ALIGN(buf) - buf;
cp = (char *)ALIGN(buf) + numptr * sizeof(char *);
pptr->p_aliases = (char **)ALIGN(buf);
len = (char *)ALIGN(buf) - buf;
cp = (char *)ALIGN(buf) + numptr * sizeof(char *);
sptr->s_aliases = (char **)ALIGN(buf);
#ifndef ALIGN
#define CORESIZE (1024*ALIGN)
#define MAX_GETCORE (size_t)(SSIZE_MAX & ~(ALIGN - 1)) /* round down ALIGN */
#define MAX_MALLOC (size_t)(SIZE_MAX - CORESIZE - 3 * ALIGN) /* overflow chk */
ASSERT(WORDSIZE == ALIGN);
if ((((size_t)addr) % ALIGN) != 0)
offset = ALIGN - (size_t)addr % ALIGN;
ASSERT((SIZE(tp) % ALIGN) == 0);
#define ALIGNMASK (ALIGN-1)
#define ALIGNMORE(addr) (ALIGN - ((uintptr_t)(addr) & ALIGNMASK))
va = (caddr_t)ALIGN(*spp, align);
offset = ALIGN(offset, tmp->ctype.alignment);
if (offset != ALIGN(offset, tmp->ctype.alignment))
offset = ALIGN(offset, tmp->ctype.alignment);
cur = ALIGN(cur, tmp->ctype.alignment);
#define ECORE_ALIGN(x, a) ALIGN(x, a)
#define ECORE_ALIGN(x, a) ALIGN(x, a)
text = ALIGN((uintptr_t)dest, tp->align);
textptr = ALIGN(textptr, tp->align);
text = ALIGN((uintptr_t)mp->text, tp->align);
data = ALIGN((uintptr_t)mp->data, dp->align);
bits_ptr = ALIGN(bits_ptr, shp->sh_addralign);
textptr = ALIGN(textptr, shp->sh_addralign);
if ((err = do_symbols(mp, ALIGN(mp->bss, mp->bss_align))) < 0)
bss_ptr = ALIGN(bss_ptr, sp->st_value);
va = ALIGN((uintptr_t)*spp, align);
mp->data_size = ALIGN(mp->data_size, data_align);
mp->data_size += ALIGN(shp->sh_size, 8);
mp->text_size = ALIGN(mp->text_size, text_align);
mp->text_size += ALIGN(shp->sh_size, 8);
pp->size = ALIGN(pp->size, shp->sh_addralign);
pp->size += ALIGN(shp->sh_size, 8);
tp->size = ALIGN(tp->size, 8);
dp->size = ALIGN(dp->size, 8);
pp->size = ALIGN(pp->size, shp->sh_addralign);
pp->size += ALIGN(shp->sh_size, 8);
tp->size = ALIGN(tp->size, 8);
dp->size = ALIGN(dp->size, 8);
ALIGN(littlehand, PAGESIZE) - (uintptr_t)littlehand;
base = ALIGN(base, (1ul << PA_SLICE_SHIFT));
base = ALIGN(base, (1ul << PA_SLICE_SHIFT));