size              200 host/buildvm_asm.c 	name, name, name, name, name, name, name, name, size, name);
size              210 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              171 host/buildvm_peobj.c   aux.size = pesect[sect].size;
size              191 host/buildvm_peobj.c   sofs += (pesect[PEOBJ_SECT_TEXT].size = (uint32_t)ctx->codesz);
size              200 host/buildvm_peobj.c   sofs += (pesect[PEOBJ_SECT_PDATA].size = 6*4);
size              208 host/buildvm_peobj.c   sofs += (pesect[PEOBJ_SECT_XDATA].size = 8*2+4+6*2);  /* See below. */
size              216 host/buildvm_peobj.c   sofs += (pesect[PEOBJ_SECT_SXDATA].size = 4);
size              224 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 && l->name; l++) size++;
size              111 lib_aux.c        return size;
size              275 lib_base.c     	    ct->size <= 4 && !(ct->size == 4 && (ct->info & CTF_UNSIGNED))) {
size              382 lib_base.c         *size = 0;
size              386 lib_base.c         return lua_tolstring(L, 5, size);
size              500 lib_base.c         size_t size;
size              503 lib_base.c           size = len;
size              509 lib_base.c           str = lua_tolstring(L, -1, &size);
size              516 lib_base.c         fwrite(str, 1, size, stdout);
size              298 lib_ffi.c            setstrV(L, L->top-1, lj_ctype_repr_complex(L, cdataptr(cd), ct->size));
size              300 lib_ffi.c          } else if (ct->size == 8 && ctype_isinteger(ct->info)) {
size              311 lib_ffi.c      	p = cdata_getptr(p, ct->size);
size              406 lib_ffi.c      	if (ctype_attrib(d->info) == CTA_QUAL) qual |= d->size;
size              437 lib_ffi.c        if (ctype_isptr(ct->info) && (LJ_32 || ct->size == 8)) {
size              540 lib_ffi.c          GCcdata *cd = lj_cdata_new(cts, id, d->size);
size              570 lib_ffi.c          if (ct->size != CTSIZE_INVALID)
size              571 lib_ffi.c            setintV(lj_tab_setstr(L, t, lj_str_newlit(L, "size")), (int32_t)ct->size);
size              599 lib_ffi.c      	       ct1->size == ct2->size) {
size              626 lib_ffi.c            sz = ctype_hassize(ct->info) ? ct->size : CTSIZE_INVALID;
size              653 lib_ffi.c        if (ctype_isstruct(ct->info) && ct->size != CTSIZE_INVALID) {
size              118 lib_string.c     lj_buf_putmem((SBuf *)sb, p, (MSize)size);
size              147 lj_alloc.c       long st = ntavm(INVALID_HANDLE_VALUE, &ptr, NTAVM_ZEROBITS, &size,
size              158 lj_alloc.c       long st = ntavm(INVALID_HANDLE_VALUE, &ptr, NTAVM_ZEROBITS, &size,
size              170 lj_alloc.c       void *ptr = VirtualAlloc(0, size, MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE);
size              179 lj_alloc.c       void *ptr = VirtualAlloc(0, size, MEM_RESERVE|MEM_COMMIT|MEM_TOP_DOWN,
size              193 lj_alloc.c       while (size) {
size              197 lj_alloc.c     	minfo.State != MEM_COMMIT || minfo.RegionSize > size)
size              202 lj_alloc.c         size -= minfo.RegionSize;
size              256 lj_alloc.c         void *p = mmap((void *)hint_addr, size, MMAP_PROT, MMAP_FLAGS_PROBE, -1, 0);
size              260 lj_alloc.c           hint_addr = addr + size;
size              265 lj_alloc.c           munmap(p, size);
size              273 lj_alloc.c     	if (((hint_addr + size) >> LJ_ALLOC_MBITS) != 0)
size              313 lj_alloc.c         return mmap_probe(size);
size              317 lj_alloc.c         void *ptr = mmap((void *)LJ_ALLOC_MMAP32_START, size, MMAP_PROT, MAP_32BIT|MMAP_FLAGS, -1, 0);
size              323 lj_alloc.c           return mmap_probe(size);
size              333 lj_alloc.c     #define CALL_MMAP(size)		mmap_map32(size)
size              335 lj_alloc.c     #define CALL_MMAP(size)		mmap_probe(size)
size              340 lj_alloc.c       void *ptr = mmap(NULL, size, MMAP_PROT, MMAP_FLAGS, -1, 0);
size              363 lj_alloc.c       int ret = munmap(ptr, size);
size              524 lj_alloc.c       size_t       size;             /* allocated size */
size              580 lj_alloc.c       ((char *)(A) >= S->base && (char *)(A) < S->base + S->size)
size              587 lj_alloc.c         if (addr >= sp->base && addr < sp->base + sp->size)
size              599 lj_alloc.c         if ((char *)sp >= ss->base && (char *)sp < ss->base + ss->size)
size              951 lj_alloc.c       char *old_end = oldsp->base + oldsp->size;
size              969 lj_alloc.c       m->seg.size = tsize;
size             1021 lj_alloc.c         while (sp != 0 && tbase != sp->base + sp->size)
size             1024 lj_alloc.c           sp->size += tsize;
size             1033 lj_alloc.c     	sp->size += tsize;
size             1064 lj_alloc.c         size_t size = sp->size;
size             1071 lj_alloc.c           if (!cinuse(p) && (char *)p + psize >= base + size - TOP_FOOT_SIZE) {
size             1079 lj_alloc.c     	if (CALL_MUNMAP(base, size) == 0) {
size             1080 lj_alloc.c     	  released += size;
size             1111 lj_alloc.c           if (sp->size >= extra &&
size             1113 lj_alloc.c     	size_t newsize = sp->size - extra;
size             1115 lj_alloc.c     	if ((CALL_MREMAP(sp->base, sp->size, newsize, CALL_MREMAP_NOMOVE) != MFAIL) ||
size             1122 lj_alloc.c     	sp->size -= released;
size             1251 lj_alloc.c         m->seg.size = tsize;
size             1267 lj_alloc.c         size_t size = sp->size;
size             1269 lj_alloc.c         CALL_MUNMAP(base, size);
size               88 lj_api.c         if (size > LUAI_MAXCSTACK || (L->top - L->base + size) > LUAI_MAXCSTACK) {
size               90 lj_api.c         } else if (size > 0) {
size               91 lj_api.c           lj_state_checkstack(L, (MSize)size);
size               98 lj_api.c         if (!lua_checkstack(L, size))
size              747 lj_api.c         if (size > LJ_MAX_UDATA)
size              749 lj_api.c         ud = lj_udata_new(L, (MSize)size, getcurrenv(L));
size             1969 lj_asm_arm64.h   MCode *pe = (MCode *)((char *)mcode + size);
size               44 lj_carith.c    	p = (uint8_t *)cdata_getptr(p, ct->size);
size               74 lj_carith.c    	  ca->p[i] = (uint8_t *)&cct->size;  /* Assumes ct does not grow. */
size              160 lj_carith.c      if (ctype_isnum(ca->ct[0]->info) && ca->ct[0]->size <= 8 &&
size              161 lj_carith.c          ctype_isnum(ca->ct[1]->info) && ca->ct[1]->size <= 8) {
size              162 lj_carith.c        CTypeID id = (((ca->ct[0]->info & CTF_UNSIGNED) && ca->ct[0]->size == 8) ||
size              163 lj_carith.c    		  ((ca->ct[1]->info & CTF_UNSIGNED) && ca->ct[1]->size == 8)) ?
size              331 lj_carith.c    	CTINFO(CT_NUM, CTF_UNSIGNED) && s->size == 8)
size               50 lj_ccall.c       memcpy(dp, sp, ctr->size);
size              147 lj_ccall.c       ccall_struct_ret(cc, rcl, dp, ctr->size);
size              154 lj_ccall.c       if (ctr->size == 2*sizeof(float)) {  /* Copy complex float from FPR. */ \
size              224 lj_ccall.c       memcpy(dp, sp, ctr->size);
size              230 lj_ccall.c       if (!(ct->info & CTF_VARARG)) memcpy(dp, &cc->fpr[0], ctr->size);
size              307 lj_ccall.c         memcpy(dp, sp, ctr->size); \
size              315 lj_ccall.c       if (ctr->size == 2*sizeof(float)) {  /* Copy complex float from FPRs. */ \
size              347 lj_ccall.c           if (LJ_TARGET_IOS && d->size < 8) goto err_nyi; \
size              358 lj_ccall.c           if (LJ_TARGET_IOS && d->size < 8) goto err_nyi; \
size              364 lj_ccall.c       if (ctype_isfp(ctr->info) && ctr->size == sizeof(float)) \
size              381 lj_ccall.c       memcpy(dp, sp, ctr->size);  /* Copy complex from GPRs. */
size              423 lj_ccall.c       if (ctype_isfp(ctr->info) && ctr->size == sizeof(float)) \
size              440 lj_ccall.c       if (ctr->size == 2*sizeof(float)) {  /* Copy complex float from GPRs. */ \
size              451 lj_ccall.c       if (ctr->size == 2*sizeof(float)) {  /* Copy complex float from FPRs. */ \
size              499 lj_ccall.c       if (ctype_isfp(ctr->info) && ctr->size == sizeof(float)) \
size              520 lj_ccall.c       if (ctr->size == 2*sizeof(float)) {  /* Copy complex float from GPRs. */ \
size              532 lj_ccall.c       if (ctype_isfp(ctr->info) && ctr->size == sizeof(float)) \
size              538 lj_ccall.c       if (ctr->size == 2*sizeof(float)) {  /* Copy complex float from FPRs. */ \
size              554 lj_ccall.c       if (ctype_isfp(ctr->info) && ctr->size == sizeof(float)) \
size              581 lj_ccall.c       memcpy(dp, sp, ctr->size);  /* Copy struct return value from GPRs. */
size              591 lj_ccall.c       CTSize sz = ct->size;
size              599 lj_ccall.c     	if (sct->size == sz)
size              602 lj_ccall.c     	if (sct->size)
size              611 lj_ccall.c           if (sct->size)
size              637 lj_ccall.c         CTSize eofs, esz = cct->size, asz = ct->size;
size              645 lj_ccall.c         if ((ofs & (ct->size-1))) cl = CCALL_RCL_MEM;  /* Unaligned. */
size              653 lj_ccall.c       if (ct->size > 16) return CCALL_RCL_MEM;  /* Too big, gets memory class. */
size              657 lj_ccall.c         fofs = ofs+ct->size;
size              728 lj_ccall.c       CTSize sz = ct->size;
size              737 lj_ccall.c     	r |= sct->size;
size              740 lj_ccall.c     	r |= (sct->size >> 1);
size              752 lj_ccall.c           if (sct->size > 0) {
size              775 lj_ccall.c       CTSize sz = ct->size;
size              783 lj_ccall.c     	r |= sct->size;
size              786 lj_ccall.c     	r |= (sct->size >> 1);
size              798 lj_ccall.c           if (sct->size > 0) {
size              835 lj_ccall.c     	ft |= (sct->size == 4 ? FTYPE_FLOAT : FTYPE_DOUBLE) << 2*n;
size              881 lj_ccall.c         memcpy(dp, sp, ctr->size);
size              903 lj_ccall.c         } else if (ctype_isfp(s->info) && s->size == sizeof(float)) {
size              954 lj_ccall.c         if (!(CCALL_VECTOR_REG && (ctr->size == 8 || ctr->size == 16)))
size              958 lj_ccall.c         CTSize sz = ctr->size;
size              969 lj_ccall.c         cc->resx87 = ctr->size == sizeof(float) ? 1 : 2;
size             1001 lj_ccall.c         sz = d->size;
size             1046 lj_ccall.c         if (ctype_isinteger_or_bool(d->info) && d->size < 4) {
size             1048 lj_ccall.c     	*(uint32_t *)dp = d->size == 1 ? (uint32_t)*(uint8_t *)dp :
size             1051 lj_ccall.c     	*(int32_t *)dp = d->size == 1 ? (int32_t)*(int8_t *)dp :
size             1055 lj_ccall.c         if (isfp && d->size == sizeof(float))
size             1063 lj_ccall.c     	 ) && d->size <= 4) {
size             1129 lj_ccall.c       if (LJ_BE && ctr->size < CTSIZE_PTR &&
size             1131 lj_ccall.c         sp += (CTSIZE_PTR - ctr->size);
size             1151 lj_ccall.c         sz = ct->size;
size              453 lj_ccallback.c   if (ctype_isfp(ctr->info) && ctr->size == sizeof(float)) \
size              484 lj_ccallback.c   if (ctype_isfp(ctr->info) && ctr->size == sizeof(float)) \
size              507 lj_ccallback.c   if (ctype_isfp(ctr->info) && ctr->size == sizeof(float)) \
size              585 lj_ccallback.c       sz = (cta->size + CTSIZE_PTR-1) & ~(CTSIZE_PTR-1);
size              597 lj_ccallback.c       if (LJ_BE && cta->size < CTSIZE_PTR
size              602 lj_ccallback.c 	sp = (void *)((uint8_t *)sp + CTSIZE_PTR-cta->size);
size              640 lj_ccallback.c     if (ctype_isfp(ctr->info) && ctr->size == sizeof(float))
size              648 lj_ccallback.c     if (ctype_isinteger_or_bool(ctr->info) && ctr->size < 4) {
size              650 lj_ccallback.c 	*(uint32_t *)dp = ctr->size == 1 ? (uint32_t)*(uint8_t *)dp :
size              653 lj_ccallback.c 	*(int32_t *)dp = ctr->size == 1 ? (int32_t)*(int8_t *)dp :
size              658 lj_ccallback.c     if (ctr->size <= 4 &&
size              664 lj_ccallback.c       cts->cb.gpr[2] = ctr->size == sizeof(float) ? 1 : 2;
size              744 lj_ccallback.c   if (!ctype_isptr(ct->info) || (LJ_64 && ct->size != CTSIZE_PTR))
size              751 lj_ccallback.c 	  ctype_isptr(ctr->info) || (ctype_isnum(ctr->info) && ctr->size <= 8)))
size              762 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              467 lj_cconv.c       CTSize size = d->size, esize = dc->size, ofs = 0;
size              474 lj_cconv.c         if (ofs >= size)
size              479 lj_cconv.c       if (size != CTSIZE_INVALID) {  /* Only fill up arrays with known size. */
size              481 lj_cconv.c           for (; ofs < size; ofs += esize) memcpy(dp + ofs, dp, esize);
size              483 lj_cconv.c           memset(dp + ofs, 0, size - ofs);
size              515 lj_cconv.c     	lj_cconv_ct_tv(cts, ctype_rawchild(cts, df), dp+df->size, tv, flags);
size              517 lj_cconv.c     	lj_cconv_bf_tv(cts, df, dp+df->size, tv);
size              521 lj_cconv.c     			  dp+df->size, t, ip, flags);
size              531 lj_cconv.c       memset(dp, 0, d->size);  /* Much simpler to clear the struct first. */
size              556 lj_cconv.c           lua_assert(s->size == CTSIZE_PTR);
size              574 lj_cconv.c           lua_assert(d->size == 4);
size              575 lj_cconv.c           sp = (uint8_t *)&cct->size;
size              580 lj_cconv.c           if (!ctype_isinteger(dc->info) || dc->size != 1)
size              582 lj_cconv.c           if (d->size != 0 && d->size < sz)
size              583 lj_cconv.c     	sz = d->size;
size              673 lj_cconv.c       CTSize ofs, esize = dc->size;
size              700 lj_cconv.c     	lj_cconv_ct_tv(cts, ctype_rawchild(cts, df), dp+df->size, o + i, 0);
size              702 lj_cconv.c     	lj_cconv_bf_tv(cts, df, dp+df->size, o + i);
size              706 lj_cconv.c     			   dp+df->size, o, len, ip);
size               78 lj_cdata.c         CTSize sz = ctype_hassize(ct->info) ? ct->size : CTSIZE_PTR;
size              118 lj_cdata.c         lua_assert(ct->size == CTSIZE_PTR);
size              126 lj_cdata.c         if (ctype_attrib(ct->info) == CTA_QUAL) *qual |= ct->size;
size              147 lj_cdata.c     	p = (uint8_t *)cdata_getptr(p, ct->size);
size              180 lj_cdata.c     	  *pp = p + (ct->size >> 1);
size              200 lj_cdata.c           p = (uint8_t *)cdata_getptr(p, ct->size);
size              215 lj_cdata.c       lua_assert(ctype_isinteger(ctt->info) && ctt->size <= 4);
size              217 lj_cdata.c       if ((ctt->info & CTF_UNSIGNED) && (int32_t)ct->size < 0)
size              218 lj_cdata.c         setnumV(o, (lua_Number)(uint32_t)ct->size);
size              220 lj_cdata.c         setintV(o, (int32_t)ct->size);
size              242 lj_cdata.c         lua_assert(s->size == CTSIZE_PTR);
size              274 lj_cdata.c         lua_assert(d->size == CTSIZE_PTR);
size              282 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              310 lj_clib.c            n += ((d->size + 3) & ~3);
size              340 lj_clib.c            lua_assert(ctype_isinteger(ctt->info) && ctt->size <= 4);
size              341 lj_clib.c            if ((ctt->info & CTF_UNSIGNED) && (int32_t)ct->size < 0)
size              342 lj_clib.c      	setnumV(tv, (lua_Number)(uint32_t)ct->size);
size              344 lj_clib.c      	setintV(tv, (int32_t)ct->size);
size              498 lj_cparse.c          k->u32 = cp->ct->size; k->id = ctype_cid(cp->ct->info);
size              546 lj_cparse.c          if (!ctype_isstruct(ct->info) || ct->size == CTSIZE_INVALID ||
size              553 lj_cparse.c          k->u32 = ctype_isconstval(ct->info) ? ct->size : 0;
size              738 lj_cparse.c      decl->stack[top].size = size;
size              750 lj_cparse.c      return (decl->pos = cp_add(decl, info, size));
size              775 lj_cparse.c      CTSize size = ct->size;
size              787 lj_cparse.c          decl->attr &= ~size;  /* Remove redundant qualifiers. */
size              789 lj_cparse.c        cp_push(decl, info & ~CTMASK_CID, size);  /* Copy type. */
size              797 lj_cparse.c        cp_push(decl, info & ~CTMASK_CID, size);  /* Copy type. */
size              803 lj_cparse.c        decl->stack[cp_push(decl, info, size)].sib = ct->sib;
size              807 lj_cparse.c        cp_push(decl, info|(decl->attr & CTF_QUAL), size);
size              823 lj_cparse.c        CTInfo size = ct->size;
size              831 lj_cparse.c          csize = ctype_get(cp->cts, id)->size;
size              853 lj_cparse.c          fct->size = size;
size              858 lj_cparse.c    	cinfo |= size;
size              860 lj_cparse.c    	CTF_INSERT(cinfo, ALIGN, size);
size              861 lj_cparse.c          id = lj_ctype_intern(cp->cts, info+id, size);
size              873 lj_cparse.c    	    size = msize;  /* Override size via mode. */
size              876 lj_cparse.c    	    CTSize esize = lj_fls(size);
size              879 lj_cparse.c    	      id = lj_ctype_intern(cp->cts, info, size);
size              881 lj_cparse.c    	      size = (1u << vsize);
size              910 lj_cparse.c    	  if (size != CTSIZE_INVALID) {
size              911 lj_cparse.c    	    uint64_t xsz = (uint64_t)size * csize;
size              913 lj_cparse.c    	    size = (CTSize)xsz;
size              922 lj_cparse.c          csize = size;
size              924 lj_cparse.c          id = lj_ctype_intern(cp->cts, info+id, size);
size              952 lj_cparse.c      CTSize size;
size              960 lj_cparse.c      size = ctt->size;
size              961 lj_cparse.c      if (!ctype_isinteger(info) || !(info & CTF_CONST) || size > 4)
size              967 lj_cparse.c      k.u32 <<= 8*(4-size);
size              969 lj_cparse.c        k.u32 >>= 8*(4-size);
size              971 lj_cparse.c        k.u32 = (uint32_t)((int32_t)k.u32 >> 8*(4-size));
size              972 lj_cparse.c      (*ctp)->size = k.u32;
size             1160 lj_cparse.c          CTF_INSERT(decl->fattr, CCONV, cp->ct->size);
size             1166 lj_cparse.c          CTF_INSERT(decl->attr, MSIZEP, cp->ct->size);
size             1196 lj_cparse.c          ct->size = CTSIZE_INVALID;
size             1204 lj_cparse.c        ct->size = CTSIZE_INVALID;
size             1207 lj_cparse.c        if (ct->size != CTSIZE_INVALID || ct->sib)
size             1245 lj_cparse.c        CTInfo attr = ct->size;  /* Field declaration attributes (temp.). */
size             1275 lj_cparse.c    	ct->size = (bofs >> 3);  /* Store field offset. */
size             1284 lj_cparse.c    	  ct->size = (bofs >> 3);  /* Store field offset. */
size             1294 lj_cparse.c    	  ct->size = ((bofs & ~(csz-1)) >> 3);  /* Store container offset. */
size             1313 lj_cparse.c      sct->size = (((bofs + maxalign) & ~maxalign) >> 3);
size             1352 lj_cparse.c    	    if (ctype_isarray(tct->info) && tct->size == CTSIZE_INVALID)
size             1361 lj_cparse.c    	      ct->size = ctype_isstruct(tct->info) ?
size             1368 lj_cparse.c    		(bsz == 0 && decl.name) || 8*tct->size > CTBSZ_MAX ||
size             1369 lj_cparse.c    		bsz > ((tct->info & CTF_BOOL) ? 1 : 8*tct->size))
size             1375 lj_cparse.c    	  ct->size = decl.attr;
size             1436 lj_cparse.c    	ct->size = k.u32++;
size             1445 lj_cparse.c        ctype_get(cp->cts, eid)->size = esize;
size             1469 lj_cparse.c          if (cp->ct->size) {
size             1471 lj_cparse.c    	sz = cp->ct->size;
size             1616 lj_cparse.c          ct->size = nargs++;
size              102 lj_crecord.c         if (ct->size == sizeof(double))
size              104 lj_crecord.c         else if (ct->size == sizeof(float))
size              107 lj_crecord.c         uint32_t b = lj_fls(ct->size);
size              112 lj_crecord.c       return (LJ_64 && ct->size == 8) ? IRT_P64 : IRT_P32;
size              114 lj_crecord.c       if (ct->size == 2*sizeof(double))
size              116 lj_crecord.c       else if (ct->size == 2*sizeof(float))
size              163 lj_crecord.c         ml[mlp].ofs = df->size;
size              168 lj_crecord.c   	ml[mlp].ofs = df->size + (cct->size >> 1);
size              372 lj_crecord.c       if (s->size == sizeof(float))
size              377 lj_crecord.c       if (s->size == 1)
size              379 lj_crecord.c       else if (s->size == 2)
size              381 lj_crecord.c       else if (s->size == 4)
size              393 lj_crecord.c     CTSize dsize = d->size, ssize = s->size;
size              576 lj_crecord.c       ptrdiff_t esz = (ptrdiff_t)(s->size >> 1);
size              632 lj_crecord.c   	lua_assert(ctype_child(cts, cct)->size == 4);
size              807 lj_crecord.c       IRType t = (LJ_64 && ct->size == 8) ? IRT_P64 : IRT_P32;
size              844 lj_crecord.c         if (ctk->size == 8) {
size              846 lj_crecord.c         } else if (ctk->size == 4) {
size              853 lj_crecord.c         if (LJ_64 && ctk->size < sizeof(intptr_t) && !(ctk->info & CTF_UNSIGNED))
size              855 lj_crecord.c         if (!LJ_64 && ctk->size > sizeof(intptr_t)) {
size              874 lj_crecord.c   	  if (fct->size >= 0x80000000u &&
size              876 lj_crecord.c   	    J->base[0] = lj_ir_knum(J, (lua_Number)(uint32_t)fct->size);
size              879 lj_crecord.c   	  J->base[0] = lj_ir_kint(J, (int32_t)fct->size);
size              897 lj_crecord.c   	if (strdata(name)[0] == 'i') ofs += (ct->size >> 1);
size             1003 lj_crecord.c         CTSize ofs, esize = dc->size;
size             1049 lj_crecord.c   		      lj_ir_kintp(J, df->size + sizeof(GCcdata)));
size             1127 lj_crecord.c         if (d->size < 4) {
size             1129 lj_crecord.c   	  tr = emitconv(tr, IRT_INT, d->size==1 ? IRT_U8 : IRT_U16, 0);
size             1131 lj_crecord.c   	  tr = emitconv(tr, IRT_INT, d->size==1 ? IRT_I8 : IRT_I16,IRCONV_SEXT);
size             1133 lj_crecord.c       } else if (LJ_SOFTFP32 && ctype_isfp(d->info) && d->size > 4) {
size             1202 lj_crecord.c       tp = (LJ_64 && ct->size == 8) ? IRT_P64 : IRT_P32;
size             1304 lj_crecord.c       if (((s[0]->info & CTF_UNSIGNED) && s[0]->size == 8) ||
size             1305 lj_crecord.c   	((s[1]->info & CTF_UNSIGNED) && s[1]->size == 8)) {
size             1311 lj_crecord.c   	  s[0]->size == 4 && s[1]->size == 4) {  /* Try to narrow comparison. */
size             1567 lj_crecord.c   	if (ct->size >= 0x80000000u &&
size             1569 lj_crecord.c   	  J->base[0] = lj_ir_knum(J, (lua_Number)(uint32_t)ct->size);
size             1571 lj_crecord.c   	  J->base[0] = lj_ir_kint(J, (int32_t)ct->size);
size             1746 lj_crecord.c   	CTINFO(CT_NUM, CTF_UNSIGNED) && ct->size == 8)
size             1875 lj_crecord.c       if (ctype_isinteger_or_bool(ct->info) && ct->size <= 4 &&
size             1876 lj_crecord.c   	!(ct->size == 4 && (ct->info & CTF_UNSIGNED)))
size              173 lj_ctype.c       ct->size = 0;
size              183 lj_ctype.c       uint32_t h = ct_hashtype(info, size);
size              188 lj_ctype.c         if (ct->info == info && ct->size == size)
size              199 lj_ctype.c       cts->tab[id].size = size;
size              210 lj_ctype.c       uint32_t h = ct_hashtype(ct->info, ct->size);
size              247 lj_ctype.c           *ofs = ct->size;
size              254 lj_ctype.c     	if (ctype_attrib(cct->info) == CTA_QUAL) q |= cct->size;
size              260 lj_ctype.c     	*ofs += ct->size;
size              283 lj_ctype.c       return ctype_hassize(ct->info) ? ct->size : CTSIZE_INVALID;
size              292 lj_ctype.c         xsz = ct->size;  /* Add the struct size. */
size              305 lj_ctype.c       xsz += (uint64_t)ct->size * nelem;
size              320 lj_ctype.c     	qual |= ct->size;
size              322 lj_ctype.c     	qual |= CTFP_ALIGNED + CTALIGN(ct->size);
size              327 lj_ctype.c           *szp = ctype_isfunc(info) ? CTSIZE_INVALID : ct->size;
size              448 lj_ctype.c         CTSize size = ct->size;
size              454 lj_ctype.c     	if (size == sizeof(double)) ctype_preplit(ctr, "double");
size              455 lj_ctype.c     	else if (size == sizeof(float)) ctype_preplit(ctr, "float");
size              457 lj_ctype.c           } else if (size == 1) {
size              461 lj_ctype.c           } else if (size < 8) {
size              462 lj_ctype.c     	if (size == 4) ctype_preplit(ctr, "int");
size              467 lj_ctype.c     	ctype_prepnum(ctr, size*8);
size              488 lj_ctype.c           if (ctype_attrib(info) == CTA_QUAL) qual |= size;
size              495 lj_ctype.c     	if (LJ_64 && size == 4) ctype_preplit(ctr, "__ptr32");
size              507 lj_ctype.c     	if (size != CTSIZE_INVALID) {
size              508 lj_ctype.c     	  CTSize csize = ctype_child(ctr->cts, ct)->size;
size              509 lj_ctype.c     	  ctype_appnum(ctr, csize ? size/csize : 0);
size              515 lj_ctype.c     	if (size == 2*sizeof(float)) ctype_preplit(ctr, "float");
size              520 lj_ctype.c     	ctype_prepnum(ctr, size);
size              577 lj_ctype.c       if (size == 2*sizeof(double)) {
size              606 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              182 lj_debug.c       uint32_t size = (uint32_t)ar->i_ci >> 16;
size              184 lj_debug.c       TValue *nextframe = size ? frame + size : NULL;
size              438 lj_debug.c         uint32_t size = (uint32_t)ar->i_ci >> 16;
size              441 lj_debug.c         if (size) nextframe = frame + size;
size              533 lj_debug.c       int size;
size              534 lj_debug.c       cTValue *frame = lj_debug_frame(L, level, &size);
size              536 lj_debug.c         ar->i_ci = (size << 16) + (int)(frame - tvref(L->stack));
size              539 lj_debug.c         ar->i_ci = level - size;
size              582 lj_debug.c         int size;
size              583 lj_debug.c         cTValue *frame = lj_debug_frame(L, level, &size);
size              585 lj_debug.c           cTValue *nextframe = size ? frame+size : NULL;
size              640 lj_debug.c           level -= size;  /* Reverse frame order: quickly skip missing level. */
size              838 lj_err.c         int size;
size              839 lj_err.c         cTValue *frame = lj_debug_frame(L, level, &size);
size              840 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              831 lj_gc.c          GCobj *o = (GCobj *)g->allocf(g->allocd, NULL, 0, size);
size              835 lj_gc.c          g->gc.total += size;
size              187 lj_gdbjit.c      uintptr_t size;
size              214 lj_gdbjit.c      uint64_t size;
size              218 lj_gdbjit.c      uint32_t size;
size              479 lj_gdbjit.c      sect->size = ctx->szmcode;
size              489 lj_gdbjit.c      sect->size = sizeof(ctx->obj.sym);
size              518 lj_gdbjit.c      sym->size = ctx->szmcode;
size              703 lj_gdbjit.c      ctx->obj.sect[sect].size = (uintptr_t)(ctx->p - ctx->startp);
size               53 lj_ir.c        #define IRTSIZE(name, size)	size,
size              164 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             1555 lj_record.c    	if (!ctype_hassize(ct->info) || ct->size <= 16)