alloc
void *alloc(int bytes);
LINE *new_line = (LINE *) alloc(sizeof(LINE));
new_line->text = alloc(length + 1);
header = tail = (LINE *) alloc(sizeof(LINE)); /* Make header of list*/
line->text = alloc(length_of(text_buffer) + 1);
program->result.expression = (int *) alloc(length);
line->text = alloc(length_of(text_buffer) + 1);
start_line->text = alloc(length_of(text_buffer) + 1);
int alloc;
alloc = 0;
if (*nuids >= alloc) {
alloc = (alloc + 1) << 1;
moreuids = realloc(uids, alloc * sizeof (*uids));
if ((ret->cd = ret->d = calloc(1, ret->alloc)) == NULL) {
ret->alloc = ret->size = ret->max_size = len;
explicit_bzero(buf->d, buf->alloc);
if (buf->alloc != SSHBUF_SIZE_INIT) {
if ((d = recallocarray(buf->d, buf->alloc, SSHBUF_SIZE_INIT,
buf->alloc = SSHBUF_SIZE_INIT;
explicit_bzero(buf->d, buf->alloc);
return buf->alloc;
if (max_size < buf->alloc && max_size > buf->size) {
if ((dp = recallocarray(buf->d, buf->alloc, rlen, 1)) == NULL)
buf->alloc = rlen;
if (max_size < buf->alloc)
if (len + buf->size <= buf->alloc)
buf->size, buf->alloc, buf->off, buf->max_size); \
need = len + buf->size - buf->alloc;
rlen = ROUNDUP(buf->alloc + need, SSHBUF_SIZE_INC);
rlen = buf->alloc + need;
if ((dp = recallocarray(buf->d, buf->alloc, rlen, 1)) == NULL) {
buf->alloc = rlen;
size_t alloc; /* Total bytes allocated to buf->d */
buf->alloc > buf->max_size ||
buf->size > buf->alloc ||
ret->alloc = SSHBUF_SIZE_INIT;
if (impl != NULL && impl->funcs->alloc != NULL) {
if (impl->funcs->alloc(k) != 0) {
int (*alloc)(struct sshkey *); /* optional */
#define newgold() ((struct gold *) alloc(sizeof(struct gold)))
#define newmonst(xl) ((struct monst *) alloc((xl) + sizeof(struct monst)))
#define newobj(xl) ((struct obj *) alloc((xl) + sizeof(struct obj)))
#define newtrap() ((struct trap *) alloc(sizeof(struct trap)))
#define newseg() ((struct wseg *) alloc(sizeof(struct wseg)))
void *alloc(size_t);
#define newttentry() ((struct toptenentry *) alloc(sizeof(struct toptenentry)))
ep = alloc(sizeof(*ep) + strlen(s) + 1);
ep = alloc(sizeof(*ep) + len + 1);
ep = alloc(sizeof(*ep) + lth);
#define newstring(x) ((char *) alloc(x))
objects[i].oc_uname = alloc(len);
bufr = alloc(CO);
tl = alloc(len + sizeof(*tl) + 1);
usedbits = alloc(i + 1);
tl = alloc(strlen(toplines) + sizeof(*tl) + 1);
char *alloc = NULL;
dmsg_uuid_to_str(&msg->any.lnk_conn.peer_id, &alloc),
free(alloc);
char *alloc = NULL;
&alloc),
free(alloc);
dmsg_uuid_to_str(&cls->peer_id, &alloc),
free(alloc);
alloc:
goto alloc;
goto alloc;
goto alloc;
goto alloc;
static daddr_t alloc(void);
bp[i].new=alloc()/sblock.fs_frag;
node.di_db[0] = alloc(sblock.fs_fsize, node.di_mode);
daddr_t alloc(int, int);
node.di_db[0] = alloc(node.di_size, node.di_mode);
int alloc, off; /* alloc/off for RO/W arrays */
alloc = off = 0; /* shut up stupid gcc */
alloc = 8;
cfg->vpd.vpd_ros = kmalloc(alloc *
alloc = 8;
cfg->vpd.vpd_w = kmalloc(alloc *
if (off == alloc) {
(alloc *= 2) * sizeof(*cfg->vpd.vpd_ros),
if (off == alloc) {
(alloc *= 2) * sizeof(*cfg->vpd.vpd_w),
ACPI_MCFG_ALLOCATION *alloc, *end;
alloc = (ACPI_MCFG_ALLOCATION *)((ACPI_TABLE_MCFG *)hdr + 1);
while (alloc < end) {
if (alloc->PciSegment == 0) {
pcie_cfgregopen(alloc->Address, alloc->StartBusNumber,
alloc->EndBusNumber);
alloc++;
agp_allocate_user(device_t dev, agp_allocate *alloc)
alloc->type,
alloc->pg_count << AGP_PAGE_SHIFT);
alloc->key = mem->am_id;
alloc->physical = mem->am_physical;
void (*alloc)(device_t dev);
ch->dma->alloc = ata_dmaalloc;
ch->dma->alloc(dev);
struct _SET_VOLTAGE_PS_ALLOCATION alloc;
args->out.alloc.ctx_id = id;
int alloc = max(index + 1, config->num_connector);
alloc * sizeof(*state->connectors), M_DRM,
sizeof(*state->connectors) * (alloc - state->num_connector));
state->num_connector = alloc;
struct skl_ddb_entry *alloc, /* out */
alloc->start = 0;
alloc->end = 0;
*alloc = to_intel_crtc_state(for_crtc->state)->wm.skl.ddb;
alloc->start = ddb_size * width_before_pipe / total_width;
alloc->end = ddb_size * (width_before_pipe + pipe_width) / total_width;
struct skl_ddb_entry *alloc = &cstate->wm.skl.ddb;
alloc->start = alloc->end = 0;
alloc, &num_active);
alloc_size = skl_ddb_entry_size(alloc);
ddb->plane[pipe][PLANE_CURSOR].start = alloc->end - minimum[PLANE_CURSOR];
ddb->plane[pipe][PLANE_CURSOR].end = alloc->end;
start = alloc->start;
} alloc;
struct _SET_VOLTAGE_PS_ALLOCATION alloc;
for (i = 0; i < md->synth.alloc.max_voice; i++)
if ((md->synth.alloc.map[i] & 0xff00) == key) {
dumpz(alloc);
objcache_alloc_fn *alloc;
objcache_alloc_fn *alloc, objcache_free_fn *free,
oc->alloc = alloc;
obj = oc->alloc(oc->allocator_args, ocflags);
u_int alloc; /* Count of memory allocations */
KASSERT (z == uh->alloc,
uh->alloc, z, line));
uh->alloc++;
uh->alloc--;
KASSERT(uh->alloc == 0, ("UNR memory leak in delete_unrhdr"));
uh, uh->low, uh->high, uh->first, uh->last, uh->busy, uh->alloc);
rv = alloc(size);
rv = alloc(size);
#define _PROP_MALLOC(s, t) alloc((s))
#define _PROP_POOL_GET(p) alloc((p))
objcache_alloc_fn *alloc, objcache_free_fn *free,
SDT_PROBE3(ext2fs, , alloc,
SDT_PROBE2(ext2fs, , alloc, ext2_blkfree_bad_block,
SDT_PROBE2(ext2fs, , alloc, ext2_vfree_doublefree,
SDT_PROBE2(ext2fs, , alloc, trace, 1, "cannot allocate data block");
SDT_PROBE2(ext2fs, , alloc, trace, 1, "cannot allocate meta block");
SDT_PROBE3(ext2fs, , alloc, ext2_reallocblks_realloc,
SDT_PROBE1(ext2fs, , alloc, ext2_reallocblks_bap, *bap);
SDT_PROBE1(ext2fs, , alloc, ext2_reallocblks_blkno, blkno);
SDT_PROBE2(ext2fs, , alloc, trace, 1, "out of inodes");
SDT_PROBE_DEFINE2(ext2fs, , alloc, trace, "int", "char*");
SDT_PROBE_DEFINE3(ext2fs, , alloc, ext2_reallocblks_realloc,
SDT_PROBE_DEFINE1(ext2fs, , alloc, ext2_reallocblks_bap, "uint32_t");
SDT_PROBE_DEFINE1(ext2fs, , alloc, ext2_reallocblks_blkno, "e2fs_daddr_t");
SDT_PROBE_DEFINE2(ext2fs, , alloc, ext2_b_bitmap_validate_error, "char*", "int");
SDT_PROBE_DEFINE3(ext2fs, , alloc, ext2_nodealloccg_bmap_corrupted,
SDT_PROBE_DEFINE2(ext2fs, , alloc, ext2_blkfree_bad_block, "ino_t", "e4fs_daddr_t");
SDT_PROBE_DEFINE2(ext2fs, , alloc, ext2_vfree_doublefree, "char*", "ino_t");
SDT_PROBE2(ext2fs, , alloc, ext2_b_bitmap_validate_error,
SDT_PROBE2(ext2fs, , alloc, ext2_b_bitmap_validate_error,
SDT_PROBE2(ext2fs, , alloc, ext2_b_bitmap_validate_error,
void *(*alloc)(size_t, void *);
p = (i->alloc)(i->key_offset + (*end - start) + 1, i->data);
h->info.alloc = info->alloc;
int alloc;
alloc = ccp->his_reject == 0 && ccp->out.opt == NULL;
if (!alloc)
if (alloc || *o == NULL) {
if (alloc)