size              165 host/buildvm_asm.c 	name, name, name, name, name, name, name, name, size, name);
size              175 host/buildvm_asm.c       name, name, name, isfunc ? "function" : "object", name, size, name);
size               36 host/buildvm_peobj.c   uint32_t size;
size               70 host/buildvm_peobj.c   uint32_t size;
size              169 host/buildvm_peobj.c   aux.size = pesect[sect].size;
size              189 host/buildvm_peobj.c   sofs += (pesect[PEOBJ_SECT_TEXT].size = (uint32_t)ctx->codesz);
size              198 host/buildvm_peobj.c   sofs += (pesect[PEOBJ_SECT_PDATA].size = 6*4);
size              206 host/buildvm_peobj.c   sofs += (pesect[PEOBJ_SECT_XDATA].size = 8*2+4+6*2);  /* See below. */
size              215 host/buildvm_peobj.c   sofs += (pesect[PEOBJ_SECT_RDATA_Z].size = (uint32_t)strlen(ctx->dasm_ident)+1);
size              367 host/minilua.c #define lmod(s,size)(check_exp((size&(size-1))==0,(cast(int,(s)&((size)-1)))))
size              383 host/minilua.c #define luaM_growvector(L,v,nelems,size,t,limit,e)if((nelems)+1>(size))((v)=cast(t*,luaM_growaux_(L,v,&(size),sizeof(t),limit,e)))
size              404 host/minilua.c #define luaZ_resizebuffer(L,buff,size)(luaM_reallocvector(L,(buff)->buffer,(buff)->buffsize,size,char),(buff)->buffsize=size)
size              420 host/minilua.c int size;
size              534 host/minilua.c if(*size>=limit/2){
size              535 host/minilua.c if(*size>=limit)
size              540 host/minilua.c newsize=(*size)*2;
size              544 host/minilua.c newblock=luaM_reallocv(L,block,*size,newsize,size_elems);
size              545 host/minilua.c *size=newsize;
size              923 host/minilua.c int size=(c->c.isC)?sizeCclosure(c->c.nupvalues):
size              925 host/minilua.c luaM_freemem(L,c,size);
size             1268 host/minilua.c for(i=0;i<tb->size;i++){
size             1279 host/minilua.c luaM_freearray(L,tb->hash,tb->size,TString*);
size             1280 host/minilua.c tb->size=newsize;
size             1298 host/minilua.c h=lmod(h,tb->size);
size             1302 host/minilua.c if(tb->nuse>cast(lu_int32,tb->size)&&tb->size<=(INT_MAX-2)/2)
size             1303 host/minilua.c luaS_resize(L,tb->size*2);
size             1313 host/minilua.c for(o=G(L)->strt.hash[lmod(h,G(L)->strt.size)];
size             1485 host/minilua.c luaM_reallocvector(L,t->array,t->sizearray,size,TValue);
size             1486 host/minilua.c for(i=t->sizearray;i<size;i++)
size             1488 host/minilua.c t->sizearray=size;
size             1492 host/minilua.c if(size==0){
size             1498 host/minilua.c lsize=ceillog2(size);
size             1501 host/minilua.c size=twoto(lsize);
size             1502 host/minilua.c t->node=luaM_newvector(L,size,Node);
size             1503 host/minilua.c for(i=0;i<size;i++){
size             1511 host/minilua.c t->lastfree=gnode(t,size);
size             2033 host/minilua.c if(g->strt.nuse<cast(lu_int32,g->strt.size/4)&&
size             2034 host/minilua.c g->strt.size>32*2)
size             2035 host/minilua.c luaS_resize(L,g->strt.size/2);
size             2076 host/minilua.c for(i=0;i<g->strt.size;i++)
size             2143 host/minilua.c if(g->sweepstrgc>=g->strt.size)
size             2316 host/minilua.c luaM_freearray(L,G(L)->strt.hash,G(L)->strt.size,TString*);
size             2346 host/minilua.c g->strt.size=0;
size             2596 host/minilua.c size_t size;
size             2599 host/minilua.c buff=z->reader(L,z->data,&size);
size             2600 host/minilua.c if(buff==NULL||size==0)return(-1);
size             2601 host/minilua.c z->n=size-1;
size             5351 host/minilua.c if(size>8000||(L->top-L->base+size)>8000)
size             5353 host/minilua.c else if(size>0){
size             5354 host/minilua.c luaD_checkstack(L,size);
size             5355 host/minilua.c if(L->ci->top<L->top+size)
size             5356 host/minilua.c L->ci->top=L->top+size;
size             5830 host/minilua.c u=luaS_newudata(L,size,getcurrenv(L));
size             6000 host/minilua.c int size=0;
size             6001 host/minilua.c for(;l->name;l++)size++;
size             6002 host/minilua.c return size;
size             6007 host/minilua.c int size=libsize(l);
size             6012 host/minilua.c if(luaL_findtable(L,(-10002),libname,size)!=NULL)
size             6128 host/minilua.c *size=1;
size             6132 host/minilua.c *size=fread(lf->buff,1,sizeof(lf->buff),lf->f);
size             6133 host/minilua.c return(*size>0)?lf->buff:NULL;
size             6182 host/minilua.c size_t size;
size             6187 host/minilua.c if(ls->size==0)return NULL;
size             6188 host/minilua.c *size=ls->size;
size             6189 host/minilua.c ls->size=0;
size             6196 host/minilua.c ls.size=size;
size              109 lib_aux.c        int size = 0;
size              110 lib_aux.c        for (; l->name; l++) size++;
size              111 lib_aux.c        return size;
size              119 lib_aux.c          int size = libsize(l);
size              126 lib_aux.c            if (luaL_findtable(L, LUA_GLOBALSINDEX, libname, size) != NULL)
size              270 lib_base.c     	    ct->size <= 4 && !(ct->size == 4 && (ct->info & CTF_UNSIGNED))) {
size              393 lib_base.c         *size = 0;
size              397 lib_base.c         return lua_tolstring(L, 5, size);
size              510 lib_base.c         size_t size;
size              514 lib_base.c           size = strV(o)->len;
size              518 lib_base.c           size = (size_t)(buf+LJ_STR_INTBUF-p);
size              522 lib_base.c           size = lj_str_bufnum(buf, o);
size              529 lib_base.c           str = lua_tolstring(L, -1, &size);
size              536 lib_base.c         fwrite(str, 1, size, stdout);
size              297 lib_ffi.c            setstrV(L, L->top-1, lj_ctype_repr_complex(L, cdataptr(cd), ct->size));
size              299 lib_ffi.c          } else if (ct->size == 8 && ctype_isinteger(ct->info)) {
size              310 lib_ffi.c      	p = cdata_getptr(p, ct->size);
size              405 lib_ffi.c      	if (ctype_attrib(d->info) == CTA_QUAL) qual |= d->size;
size              436 lib_ffi.c        if (ctype_isptr(ct->info) && (LJ_32 || ct->size == 8)) {
size              542 lib_ffi.c          GCcdata *cd = lj_cdata_new(cts, id, d->size);
size              576 lib_ffi.c      	       ct1->size == ct2->size) {
size              603 lib_ffi.c            sz = ctype_hassize(ct->info) ? ct->size : CTSIZE_INVALID;
size              630 lib_ffi.c        if (ctype_isstruct(ct->info) && ct->size != CTSIZE_INVALID) {
size              147 lib_string.c     luaL_addlstring((luaL_Buffer *)b, (const char *)p, size);
size              103 lj_alloc.c       long st = ntavm(INVALID_HANDLE_VALUE, &ptr, NTAVM_ZEROBITS, &size,
size              114 lj_alloc.c       long st = ntavm(INVALID_HANDLE_VALUE, &ptr, NTAVM_ZEROBITS, &size,
size              128 lj_alloc.c       void *ptr = VirtualAlloc(0, size, MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE);
size              137 lj_alloc.c       void *ptr = VirtualAlloc(0, size, MEM_RESERVE|MEM_COMMIT|MEM_TOP_DOWN,
size              151 lj_alloc.c       while (size) {
size              155 lj_alloc.c     	minfo.State != MEM_COMMIT || minfo.RegionSize > size)
size              160 lj_alloc.c         size -= minfo.RegionSize;
size              192 lj_alloc.c       void *ptr = mmap((void *)MMAP_REGION_START, size, MMAP_PROT, MAP_32BIT|MMAP_FLAGS, -1, 0);
size              233 lj_alloc.c         void *p = mmap((void *)alloc_hint, size, MMAP_PROT, MMAP_FLAGS, -1, 0);
size              235 lj_alloc.c     	(uintptr_t)p + size < MMAP_REGION_END) {
size              236 lj_alloc.c           alloc_hint = (uintptr_t)p + size;
size              240 lj_alloc.c         if (p != CMFAIL) munmap(p, size);
size              243 lj_alloc.c         if (alloc_hint + size < MMAP_REGION_END) continue;
size              265 lj_alloc.c       void *ptr = mmap(NULL, size, MMAP_PROT, MMAP_FLAGS, -1, 0);
size              278 lj_alloc.c       int ret = munmap(ptr, size);
size              431 lj_alloc.c       size_t       size;             /* allocated size */
size              487 lj_alloc.c       ((char *)(A) >= S->base && (char *)(A) < S->base + S->size)
size              494 lj_alloc.c         if (addr >= sp->base && addr < sp->base + sp->size)
size              506 lj_alloc.c         if ((char *)sp >= ss->base && (char *)sp < ss->base + ss->size)
size              858 lj_alloc.c       char *old_end = oldsp->base + oldsp->size;
size              876 lj_alloc.c       m->seg.size = tsize;
size              928 lj_alloc.c         while (sp != 0 && tbase != sp->base + sp->size)
size              931 lj_alloc.c           sp->size += tsize;
size              940 lj_alloc.c     	sp->size += tsize;
size              971 lj_alloc.c         size_t size = sp->size;
size              978 lj_alloc.c           if (!cinuse(p) && (char *)p + psize >= base + size - TOP_FOOT_SIZE) {
size              986 lj_alloc.c     	if (CALL_MUNMAP(base, size) == 0) {
size              987 lj_alloc.c     	  released += size;
size             1018 lj_alloc.c           if (sp->size >= extra &&
size             1020 lj_alloc.c     	size_t newsize = sp->size - extra;
size             1022 lj_alloc.c     	if ((CALL_MREMAP(sp->base, sp->size, newsize, CALL_MREMAP_NOMOVE) != MFAIL) ||
size             1029 lj_alloc.c     	sp->size -= released;
size             1158 lj_alloc.c         m->seg.size = tsize;
size             1174 lj_alloc.c         size_t size = sp->size;
size             1176 lj_alloc.c         CALL_MUNMAP(base, size);
size               87 lj_api.c         if (size > LUAI_MAXCSTACK || (L->top - L->base + size) > LUAI_MAXCSTACK) {
size               89 lj_api.c         } else if (size > 0) {
size               90 lj_api.c           lj_state_checkstack(L, (MSize)size);
size               97 lj_api.c         if (!lua_checkstack(L, size))
size              696 lj_api.c         if (size > LJ_MAX_UDATA)
size              698 lj_api.c         ud = lj_udata_new(L, (MSize)size, getcurrenv(L));
size               64 lj_bcread.c        size_t size;
size               77 lj_bcread.c        buf = ls->rfunc(ls->L, ls->rdata, &size);  /* Get more data from reader. */
size               78 lj_bcread.c        if (buf == NULL || size == 0) {  /* EOF? */
size               84 lj_bcread.c          MSize n = ls->sb.n + (MSize)size;
size               86 lj_bcread.c          memcpy(ls->sb.buf + ls->sb.n, buf, size);
size               90 lj_bcread.c          ls->n = (MSize)size;
size               42 lj_carith.c    	p = (uint8_t *)cdata_getptr(p, ct->size);
size               72 lj_carith.c    	  ca->p[i] = (uint8_t *)&cct->size;  /* Assumes ct does not grow. */
size              158 lj_carith.c      if (ctype_isnum(ca->ct[0]->info) && ca->ct[0]->size <= 8 &&
size              159 lj_carith.c          ctype_isnum(ca->ct[1]->info) && ca->ct[1]->size <= 8) {
size              160 lj_carith.c        CTypeID id = (((ca->ct[0]->info & CTF_UNSIGNED) && ca->ct[0]->size == 8) ||
size              161 lj_carith.c    		  ((ca->ct[1]->info & CTF_UNSIGNED) && ca->ct[1]->size == 8)) ?
size               51 lj_ccall.c       memcpy(dp, sp, ctr->size);
size              148 lj_ccall.c       ccall_struct_ret(cc, rcl, dp, ctr->size);
size              155 lj_ccall.c       if (ctr->size == 2*sizeof(float)) {  /* Copy complex float from FPR. */ \
size              225 lj_ccall.c       memcpy(dp, sp, ctr->size);
size              231 lj_ccall.c       if (!(ct->info & CTF_VARARG)) memcpy(dp, &cc->fpr[0], ctr->size);
size              306 lj_ccall.c       memcpy(dp, sp, ctr->size);  /* Copy complex from GPRs. */
size              339 lj_ccall.c       if (ctype_isfp(ctr->info) && ctr->size == sizeof(float)) \
size              354 lj_ccall.c       memcpy(dp, sp, ctr->size);  /* Copy complex from GPRs. */
size              390 lj_ccall.c       if (ctr->size == 2*sizeof(float)) {  /* Copy complex float from FPRs. */ \
size              428 lj_ccall.c       if (ctype_isfp(ctr->info) && ctr->size == sizeof(float)) \
size              437 lj_ccall.c       memcpy(dp, sp, ctr->size);  /* Copy struct return value from GPRs. */
size              447 lj_ccall.c       CTSize sz = ct->size;
size              455 lj_ccall.c     	if (sct->size == sz)
size              458 lj_ccall.c     	if (sct->size)
size              467 lj_ccall.c           if (sct->size)
size              493 lj_ccall.c         CTSize eofs, esz = cct->size, asz = ct->size;
size              501 lj_ccall.c         if ((ofs & (ct->size-1))) cl = CCALL_RCL_MEM;  /* Unaligned. */
size              509 lj_ccall.c       if (ct->size > 16) return CCALL_RCL_MEM;  /* Too big, gets memory class. */
size              513 lj_ccall.c         fofs = ofs+ct->size;
size              584 lj_ccall.c       CTSize sz = ct->size;
size              593 lj_ccall.c     	r |= sct->size;
size              596 lj_ccall.c     	r |= (sct->size >> 1);
size              608 lj_ccall.c           if (sct->size > 0) {
size              640 lj_ccall.c         } else if (ctype_isfp(s->info) && s->size == sizeof(float)) {
size              691 lj_ccall.c         if (!(CCALL_VECTOR_REG && (ctr->size == 8 || ctr->size == 16)))
size              695 lj_ccall.c         CTSize sz = ctr->size;
size              706 lj_ccall.c         cc->resx87 = ctr->size == sizeof(float) ? 1 : 2;
size              738 lj_ccall.c         sz = d->size;
size              783 lj_ccall.c         if (ctype_isinteger_or_bool(d->info) && d->size < 4) {
size              785 lj_ccall.c     	*(uint32_t *)dp = d->size == 1 ? (uint32_t)*(uint8_t *)dp :
size              788 lj_ccall.c     	*(int32_t *)dp = d->size == 1 ? (int32_t)*(int8_t *)dp :
size              847 lj_ccall.c       if (LJ_BE && ctype_isinteger_or_bool(ctr->info) && ctr->size < CTSIZE_PTR)
size              848 lj_ccall.c         sp += (CTSIZE_PTR - ctr->size);
size              868 lj_ccall.c         sz = ct->size;
size              376 lj_ccallback.c   if (ctype_isfp(ctr->info) && ctr->size == sizeof(float)) \
size              397 lj_ccallback.c   if (ctype_isfp(ctr->info) && ctr->size == sizeof(float)) \
size              465 lj_ccallback.c       sz = (cta->size + CTSIZE_PTR-1) & ~(CTSIZE_PTR-1);
size              477 lj_ccallback.c       if (LJ_BE && cta->size < CTSIZE_PTR)
size              478 lj_ccallback.c 	sp = (void *)((uint8_t *)sp + CTSIZE_PTR-cta->size);
size              511 lj_ccallback.c     if (ctype_isinteger_or_bool(ctr->info) && ctr->size < 4) {
size              513 lj_ccallback.c 	*(uint32_t *)dp = ctr->size == 1 ? (uint32_t)*(uint8_t *)dp :
size              516 lj_ccallback.c 	*(int32_t *)dp = ctr->size == 1 ? (int32_t)*(int8_t *)dp :
size              521 lj_ccallback.c       cts->cb.gpr[2] = ctr->size == sizeof(float) ? 1 : 2;
size              601 lj_ccallback.c   if (!ctype_isptr(ct->info) || (LJ_64 && ct->size != CTSIZE_PTR))
size              608 lj_ccallback.c 	  ctype_isptr(ctr->info) || (ctype_isnum(ctr->info) && ctr->size <= 8)))
size              619 lj_ccallback.c 	      (ctype_isnum(cta->info) && cta->size <= 8)) ||
size               63 lj_cconv.c           if (ctype_attrib(ct->info) == CTA_QUAL) *qual |= ct->size;
size               93 lj_cconv.c     	d->size != s->size)
size              121 lj_cconv.c       CTSize dsize = d->size, ssize = s->size;
size              213 lj_cconv.c         ssize = s->size;
size              277 lj_cconv.c         ssize = s->size;
size              284 lj_cconv.c         dsize = d->size;
size              290 lj_cconv.c         dsize = d->size;
size              299 lj_cconv.c           lj_cconv_ct_ct(cts, dc, sc, dp + dc->size, sp + sc->size, flags);
size              313 lj_cconv.c         for (sp = dp, esize = dc->size; dsize > esize; dsize -= esize) {
size              351 lj_cconv.c     	d->size == CTSIZE_INVALID || !lj_cconv_compatptr(cts, d, s, flags))
size              379 lj_cconv.c           if (ctype_isinteger(sinfo) && s->size > 4) goto copyval;
size              395 lj_cconv.c           uint32_t b = s->size == 1 ? (*sp != 0) : (*(int *)sp != 0);
size              408 lj_cconv.c         sz = s->size;
size              465 lj_cconv.c       CTSize size = d->size, esize = dc->size, ofs = 0;
size              472 lj_cconv.c         if (ofs >= size)
size              477 lj_cconv.c       if (size != CTSIZE_INVALID) {  /* Only fill up arrays with known size. */
size              479 lj_cconv.c           for (; ofs < size; ofs += esize) memcpy(dp + ofs, dp, esize);
size              481 lj_cconv.c           memset(dp + ofs, 0, size - ofs);
size              513 lj_cconv.c     	lj_cconv_ct_tv(cts, ctype_rawchild(cts, df), dp+df->size, tv, flags);
size              515 lj_cconv.c     	lj_cconv_bf_tv(cts, df, dp+df->size, tv);
size              519 lj_cconv.c     			  dp+df->size, t, ip, flags);
size              529 lj_cconv.c       memset(dp, 0, d->size);  /* Much simpler to clear the struct first. */
size              554 lj_cconv.c           lua_assert(s->size == CTSIZE_PTR);
size              572 lj_cconv.c           lua_assert(d->size == 4);
size              573 lj_cconv.c           sp = (uint8_t *)&cct->size;
size              578 lj_cconv.c           if (!ctype_isinteger(dc->info) || dc->size != 1)
size              580 lj_cconv.c           if (d->size != 0 && d->size < sz)
size              581 lj_cconv.c     	sz = d->size;
size              671 lj_cconv.c       CTSize ofs, esize = dc->size;
size              698 lj_cconv.c     	lj_cconv_ct_tv(cts, ctype_rawchild(cts, df), dp+df->size, o + i, 0);
size              700 lj_cconv.c     	lj_cconv_bf_tv(cts, df, dp+df->size, o + i);
size              704 lj_cconv.c     			   dp+df->size, o, len, ip);
size               70 lj_cdata.c         CTSize sz = ctype_hassize(ct->info) ? ct->size : CTSIZE_PTR;
size              109 lj_cdata.c         lua_assert(ct->size == CTSIZE_PTR);
size              117 lj_cdata.c         if (ctype_attrib(ct->info) == CTA_QUAL) *qual |= ct->size;
size              133 lj_cdata.c     	p = (uint8_t *)cdata_getptr(p, ct->size);
size              166 lj_cdata.c     	  *pp = p + (ct->size >> 1);
size              186 lj_cdata.c           p = (uint8_t *)cdata_getptr(p, ct->size);
size              201 lj_cdata.c       lua_assert(ctype_isinteger(ctt->info) && ctt->size <= 4);
size              203 lj_cdata.c       if ((ctt->info & CTF_UNSIGNED) && (int32_t)ct->size < 0)
size              204 lj_cdata.c         setnumV(o, (lua_Number)(uint32_t)ct->size);
size              206 lj_cdata.c         setintV(o, (int32_t)ct->size);
size              228 lj_cdata.c         lua_assert(s->size == CTSIZE_PTR);
size              260 lj_cdata.c         lua_assert(d->size == CTSIZE_PTR);
size              268 lj_cdata.c           if (ctype_attrib(d->info) == CTA_QUAL) qual |= d->size;
size               43 lj_cdata.h       lua_assert((ctype_hassize(ct->info) ? ct->size : CTSIZE_PTR) == sz);
size              301 lj_clib.c            n += ((d->size + 3) & ~3);
size              331 lj_clib.c            lua_assert(ctype_isinteger(ctt->info) && ctt->size <= 4);
size              332 lj_clib.c            if ((ctt->info & CTF_UNSIGNED) && (int32_t)ct->size < 0)
size              333 lj_clib.c      	setnumV(tv, (lua_Number)(uint32_t)ct->size);
size              335 lj_clib.c      	setintV(tv, (int32_t)ct->size);
size              512 lj_cparse.c          k->u32 = cp->ct->size; k->id = ctype_cid(cp->ct->info);
size              560 lj_cparse.c          if (!ctype_isstruct(ct->info) || ct->size == CTSIZE_INVALID ||
size              567 lj_cparse.c          k->u32 = ctype_isconstval(ct->info) ? ct->size : 0;
size              752 lj_cparse.c      decl->stack[top].size = size;
size              764 lj_cparse.c      return (decl->pos = cp_add(decl, info, size));
size              789 lj_cparse.c      CTSize size = ct->size;
size              801 lj_cparse.c          decl->attr &= ~size;  /* Remove redundant qualifiers. */
size              803 lj_cparse.c        cp_push(decl, info & ~CTMASK_CID, size);  /* Copy type. */
size              811 lj_cparse.c        cp_push(decl, info & ~CTMASK_CID, size);  /* Copy type. */
size              817 lj_cparse.c        decl->stack[cp_push(decl, info, size)].sib = ct->sib;
size              821 lj_cparse.c        cp_push(decl, info|(decl->attr & CTF_QUAL), size);
size              837 lj_cparse.c        CTInfo size = ct->size;
size              845 lj_cparse.c          csize = ctype_get(cp->cts, id)->size;
size              867 lj_cparse.c          fct->size = size;
size              872 lj_cparse.c    	cinfo |= size;
size              874 lj_cparse.c    	CTF_INSERT(cinfo, ALIGN, size);
size              875 lj_cparse.c          id = lj_ctype_intern(cp->cts, info+id, size);
size              887 lj_cparse.c    	    size = msize;  /* Override size via mode. */
size              890 lj_cparse.c    	    CTSize esize = lj_fls(size);
size              893 lj_cparse.c    	      id = lj_ctype_intern(cp->cts, info, size);
size              895 lj_cparse.c    	      size = (1u << vsize);
size              924 lj_cparse.c    	  if (size != CTSIZE_INVALID) {
size              925 lj_cparse.c    	    uint64_t xsz = (uint64_t)size * csize;
size              927 lj_cparse.c    	    size = (CTSize)xsz;
size              936 lj_cparse.c          csize = size;
size              938 lj_cparse.c          id = lj_ctype_intern(cp->cts, info+id, size);
size              966 lj_cparse.c      CTSize size;
size              974 lj_cparse.c      size = ctt->size;
size              975 lj_cparse.c      if (!ctype_isinteger(info) || !(info & CTF_CONST) || size > 4)
size              981 lj_cparse.c      k.u32 <<= 8*(4-size);
size              983 lj_cparse.c        k.u32 >>= 8*(4-size);
size              985 lj_cparse.c        k.u32 = (uint32_t)((int32_t)k.u32 >> 8*(4-size));
size              986 lj_cparse.c      (*ctp)->size = k.u32;
size             1174 lj_cparse.c          CTF_INSERT(decl->fattr, CCONV, cp->ct->size);
size             1180 lj_cparse.c          CTF_INSERT(decl->attr, MSIZEP, cp->ct->size);
size             1210 lj_cparse.c          ct->size = CTSIZE_INVALID;
size             1218 lj_cparse.c        ct->size = CTSIZE_INVALID;
size             1221 lj_cparse.c        if (ct->size != CTSIZE_INVALID || ct->sib)
size             1259 lj_cparse.c        CTInfo attr = ct->size;  /* Field declaration attributes (temp.). */
size             1289 lj_cparse.c    	ct->size = (bofs >> 3);  /* Store field offset. */
size             1298 lj_cparse.c    	  ct->size = (bofs >> 3);  /* Store field offset. */
size             1308 lj_cparse.c    	  ct->size = ((bofs & ~(csz-1)) >> 3);  /* Store container offset. */
size             1327 lj_cparse.c      sct->size = (((bofs + maxalign) & ~maxalign) >> 3);
size             1366 lj_cparse.c    	    if (ctype_isarray(tct->info) && tct->size == CTSIZE_INVALID)
size             1375 lj_cparse.c    	      ct->size = ctype_isstruct(tct->info) ?
size             1382 lj_cparse.c    		(bsz == 0 && decl.name) || 8*tct->size > CTBSZ_MAX ||
size             1383 lj_cparse.c    		bsz > ((tct->info & CTF_BOOL) ? 1 : 8*tct->size))
size             1389 lj_cparse.c    	  ct->size = decl.attr;
size             1450 lj_cparse.c    	ct->size = k.u32++;
size             1459 lj_cparse.c        ctype_get(cp->cts, eid)->size = esize;
size             1483 lj_cparse.c          if (cp->ct->size) {
size             1485 lj_cparse.c    	sz = cp->ct->size;
size             1630 lj_cparse.c          ct->size = nargs++;
size              101 lj_crecord.c         if (ct->size == sizeof(double))
size              103 lj_crecord.c         else if (ct->size == sizeof(float))
size              106 lj_crecord.c         uint32_t b = lj_fls(ct->size);
size              111 lj_crecord.c       return (LJ_64 && ct->size == 8) ? IRT_P64 : IRT_P32;
size              113 lj_crecord.c       if (ct->size == 2*sizeof(double))
size              115 lj_crecord.c       else if (ct->size == 2*sizeof(float))
size              162 lj_crecord.c         ml[mlp].ofs = df->size;
size              167 lj_crecord.c   	ml[mlp].ofs = df->size + (cct->size >> 1);
size              371 lj_crecord.c       if (s->size == sizeof(float))
size              376 lj_crecord.c       if (s->size == 1)
size              378 lj_crecord.c       else if (s->size == 2)
size              380 lj_crecord.c       else if (s->size == 4)
size              392 lj_crecord.c     CTSize dsize = d->size, ssize = s->size;
size              575 lj_crecord.c       ptrdiff_t esz = (ptrdiff_t)(s->size >> 1);
size              631 lj_crecord.c   	lua_assert(ctype_child(cts, cct)->size == 4);
size              741 lj_crecord.c       IRType t = (LJ_64 && ct->size == 8) ? IRT_P64 : IRT_P32;
size              778 lj_crecord.c         if (ctk->size == 8) {
size              780 lj_crecord.c         } else if (ctk->size == 4) {
size              787 lj_crecord.c         if (LJ_64 && ctk->size < sizeof(intptr_t) && !(ctk->info & CTF_UNSIGNED))
size              789 lj_crecord.c         if (!LJ_64 && ctk->size > sizeof(intptr_t)) {
size              807 lj_crecord.c   	  if (fct->size >= 0x80000000u &&
size              809 lj_crecord.c   	    J->base[0] = lj_ir_knum(J, (lua_Number)(uint32_t)fct->size);
size              812 lj_crecord.c   	  J->base[0] = lj_ir_kint(J, (int32_t)fct->size);
size              828 lj_crecord.c   	if (strdata(name)[0] == 'i') ofs += (ct->size >> 1);
size              915 lj_crecord.c         CTSize ofs, esize = dc->size;
size              960 lj_crecord.c   		      lj_ir_kintp(J, df->size + sizeof(GCcdata)));
size             1037 lj_crecord.c         if (d->size < 4) {
size             1039 lj_crecord.c   	  tr = emitconv(tr, IRT_INT, d->size==1 ? IRT_U8 : IRT_U16, 0);
size             1041 lj_crecord.c   	  tr = emitconv(tr, IRT_INT, d->size==1 ? IRT_I8 : IRT_I16,IRCONV_SEXT);
size             1043 lj_crecord.c       } else if (LJ_SOFTFP && ctype_isfp(d->info) && d->size > 4) {
size             1112 lj_crecord.c       tp = (LJ_64 && ct->size == 8) ? IRT_P64 : IRT_P32;
size             1215 lj_crecord.c       if (((s[0]->info & CTF_UNSIGNED) && s[0]->size == 8) ||
size             1216 lj_crecord.c   	((s[1]->info & CTF_UNSIGNED) && s[1]->size == 8)) {
size             1222 lj_crecord.c   	  s[0]->size == 4 && s[1]->size == 4) {  /* Try to narrow comparison. */
size             1481 lj_crecord.c   	if (ct->size >= 0x80000000u &&
size             1483 lj_crecord.c   	  J->base[0] = lj_ir_knum(J, (lua_Number)(uint32_t)ct->size);
size             1485 lj_crecord.c   	  J->base[0] = lj_ir_kint(J, (int32_t)ct->size);
size             1657 lj_crecord.c       if (ctype_isinteger_or_bool(ct->info) && ct->size <= 4 &&
size             1658 lj_crecord.c   	!(ct->size == 4 && (ct->info & CTF_UNSIGNED)))
size              169 lj_ctype.c       ct->size = 0;
size              179 lj_ctype.c       uint32_t h = ct_hashtype(info, size);
size              184 lj_ctype.c         if (ct->info == info && ct->size == size)
size              195 lj_ctype.c       cts->tab[id].size = size;
size              206 lj_ctype.c       uint32_t h = ct_hashtype(ct->info, ct->size);
size              243 lj_ctype.c           *ofs = ct->size;
size              250 lj_ctype.c     	if (ctype_attrib(cct->info) == CTA_QUAL) q |= cct->size;
size              256 lj_ctype.c     	*ofs += ct->size;
size              279 lj_ctype.c       return ctype_hassize(ct->info) ? ct->size : CTSIZE_INVALID;
size              288 lj_ctype.c         xsz = ct->size;  /* Add the struct size. */
size              301 lj_ctype.c       xsz += (uint64_t)ct->size * nelem;
size              316 lj_ctype.c     	qual |= ct->size;
size              318 lj_ctype.c     	qual |= CTFP_ALIGNED + CTALIGN(ct->size);
size              323 lj_ctype.c           *szp = ctype_isfunc(info) ? CTSIZE_INVALID : ct->size;
size              444 lj_ctype.c         CTSize size = ct->size;
size              450 lj_ctype.c     	if (size == sizeof(double)) ctype_preplit(ctr, "double");
size              451 lj_ctype.c     	else if (size == sizeof(float)) ctype_preplit(ctr, "float");
size              453 lj_ctype.c           } else if (size == 1) {
size              457 lj_ctype.c           } else if (size < 8) {
size              458 lj_ctype.c     	if (size == 4) ctype_preplit(ctr, "int");
size              463 lj_ctype.c     	ctype_prepnum(ctr, size*8);
size              484 lj_ctype.c           if (ctype_attrib(info) == CTA_QUAL) qual |= size;
size              491 lj_ctype.c     	if (LJ_64 && size == 4) ctype_preplit(ctr, "__ptr32");
size              503 lj_ctype.c     	if (size != CTSIZE_INVALID) {
size              504 lj_ctype.c     	  CTSize csize = ctype_child(ctr->cts, ct)->size;
size              505 lj_ctype.c     	  ctype_appnum(ctr, csize ? size/csize : 0);
size              511 lj_ctype.c     	if (size == 2*sizeof(float)) ctype_preplit(ctr, "float");
size              516 lj_ctype.c     	ctype_prepnum(ctr, size);
size              574 lj_ctype.c       if (size == 2*sizeof(double)) {
size              603 lj_ctype.c         ct->size = (CTSize)((int32_t)(info << 16) >> 26);
size              145 lj_ctype.h       CTSize size;		/* Type size or other info. */
size               33 lj_debug.c           *size = (int)(nextframe - frame);
size               45 lj_debug.c       *size = level;
size              196 lj_debug.c       uint32_t size = (uint32_t)ar->i_ci >> 16;
size              198 lj_debug.c       TValue *nextframe = size ? frame + size : NULL;
size              449 lj_debug.c         uint32_t size = (uint32_t)ar->i_ci >> 16;
size              452 lj_debug.c         if (size) nextframe = frame + size;
size              544 lj_debug.c       int size;
size              545 lj_debug.c       cTValue *frame = lj_debug_frame(L, level, &size);
size              547 lj_debug.c         ar->i_ci = (size << 16) + (int)(frame - tvref(L->stack));
size              550 lj_debug.c         ar->i_ci = level - size;
size              787 lj_err.c         int size;
size              788 lj_err.c         cTValue *frame = lj_debug_frame(L, level, &size);
size              789 lj_err.c         lj_debug_addloc(L, "", frame, size ? frame+size : NULL);
size              183 lj_func.c        MSize size = isluafunc(fn) ? sizeLfunc((MSize)fn->l.nupvalues) :
size              185 lj_func.c        lj_mem_free(g, fn, size);
size              833 lj_gc.c          GCobj *o = (GCobj *)g->allocf(g->allocd, NULL, 0, size);
size              837 lj_gc.c          g->gc.total += size;
size              185 lj_gdbjit.c      uintptr_t size;
size              212 lj_gdbjit.c      uint64_t size;
size              216 lj_gdbjit.c      uint32_t size;
size              482 lj_gdbjit.c      sect->size = ctx->szmcode;
size              492 lj_gdbjit.c      sect->size = sizeof(ctx->obj.sym);
size              521 lj_gdbjit.c      sym->size = ctx->szmcode;
size              699 lj_gdbjit.c      ctx->obj.sect[sect].size = (uintptr_t)(ctx->p - ctx->startp);
size               51 lj_ir.c        #define IRTSIZE(name, size)	size,
size              161 lj_jit.h         size_t size;		/* Size of current area. */
size               80 lj_load.c        *size = fread(ctx->buf, 1, sizeof(ctx->buf), ctx->fp);
size               81 lj_load.c        return *size > 0 ? ctx->buf : NULL;
size              124 lj_load.c        size_t size;
size              131 lj_load.c        if (ctx->size == 0) return NULL;
size              132 lj_load.c        *size = ctx->size;
size              133 lj_load.c        ctx->size = 0;
size              142 lj_load.c        ctx.size = size;
size              149 lj_load.c        return luaL_loadbufferx(L, buf, size, name, NULL);
size              287 lj_mcode.c       ((MCLink *)J->mcarea)->size = sz;
size              299 lj_mcode.c         mcode_free(J, mc, ((MCLink *)mc)->size);
size              341 lj_mcode.c         else if (LJ_UNLIKELY(mcode_setprot(ptr, ((MCLink *)ptr)->size, MCPROT_RUN)))
size              355 lj_mcode.c           if (ptr >= mc && ptr < (MCode *)((char *)mc + ((MCLink *)mc)->size)) {
size              356 lj_mcode.c     	if (LJ_UNLIKELY(mcode_setprot(mc, ((MCLink *)mc)->size, MCPROT_GEN)))
size             1308 lj_record.c    	if (!ctype_hassize(ct->info) || ct->size <= 16)
size               46 lj_str.h         ((sb)->buf = (char *)lj_mem_realloc(L, (sb)->buf, (sb)->sz, (size)), \
size               47 lj_str.h          (sb)->sz = (size))