xref: /manual/memory.texi

140 static constants.  It is allocated by exec and stays the same size for
190 space, of a fixed size.  The space is allocated once, when your program
204 In GNU C, the size of the automatic storage can be an expression
233 macro when you want to allocate space, and specify the size with an
271 in two different ways depending on their size
282 Neighboring chunks can be coalesced on a @code{free} no matter what their size
293 smaller ones and even after calling @code{free} wastes memory.  The size
314 allows you to allocate blocks of memory of any size at any time, make
344 @deftypefun {void *} malloc (size_t @var{size})
583 This function returns a pointer to a newly allocated block @var{size}
631 xmalloc (size_t size)
633   void *value = malloc (size);
677 returns a non-null pointer to a newly allocated size-zero block;
687 In @theglibc{}, @code{malloc} always fails when @var{size} exceeds
769 @cindex changing the size of a block (@code{malloc})
826 The @code{realloc} function changes the size of the block whose address is
839 Otherwise, if @code{realloc} cannot reallocate the requested size
844 @deftypefun {void *} reallocarray (void *@var{ptr}, size_t @var{nmemb}, size_t @var{size})
849 The @code{reallocarray} function changes the size of the block whose address
851 each of size @var{size}.  It is equivalent to @samp{realloc (@var{ptr},
852 @var{nmemb} * @var{size})}, except that @code{reallocarray} fails safely if
856 @code{reallocarray} should be used instead of @code{realloc} when the new size
879 xreallocarray (void *ptr, size_t nmemb, size_t size)
881   void *value = reallocarray (ptr, nmemb, size);
888 xrealloc (void *ptr, size_t size)
890   return xreallocarray (ptr, 1, size);
906 Portable programs should not attempt to reallocate blocks to be size zero.
908 might free the block and return a non-null pointer to a size-zero
914 would exceed @code{PTRDIFF_MAX} in size, to avoid problems with programs
919 In @theglibc{}, if the new size is the same as the old, @code{realloc} and
954 @var{count} elements, each of size @var{eltsize}.  Its contents are
992 @deftypefun {void *} aligned_alloc (size_t @var{alignment}, size_t @var{size})
996 The @code{aligned_alloc} function allocates a block of @var{size} bytes whose
998 power of two and @var{size} must be a multiple of @var{alignment}.
1016 @deftypefun {void *} memalign (size_t @var{boundary}, size_t @var{size})
1041 The @code{memalign} function allocates a block of @var{size} bytes whose
1063 @deftypefun int posix_memalign (void **@var{memptr}, size_t @var{alignment}, size_t @var{size})
1070 function in that it returns a buffer of @var{size} bytes aligned to a
1094 @deftypefun {void *} valloc (size_t @var{size})
1121 Using @code{valloc} is like using @code{memalign} and passing the page size
1126 valloc (size_t size)
1128   return memalign (getpagesize (), size);
1204 size such that excessive amounts of system calls can be avoided.
1212 This is the minimum size (in bytes) of the top-most, releasable chunk
1413 This is the total size of memory allocated with @code{sbrk} by
1429 This is the total size of memory allocated with @code{mmap}, in bytes.
1438 This is the total size of memory occupied by chunks handed out by
1442 This is the total size of memory occupied by free (not in use) chunks.
1445 This is the size of the top-most releasable chunk that normally
1482 @item void *malloc (size_t @var{size})
1483 Allocate a block of @var{size} bytes.  @xref{Basic Allocation}.
1489 @item void *realloc (void *@var{addr}, size_t @var{size})
1493 @item void *reallocarray (void *@var{ptr}, size_t @var{nmemb}, size_t @var{size})
1494 Change the size of a block previously allocated by @code{malloc} to
1495 @code{@var{nmemb} * @var{size}} bytes as with @code{realloc}.  @xref{Changing
1503 @item void *valloc (size_t @var{size})
1504 Allocate a block of @var{size} bytes, starting on a page boundary.
1507 @item void *aligned_alloc (size_t @var{size}, size_t @var{alignment})
1508 Allocate a block of @var{size} bytes, starting on an address that is a
1511 @item int posix_memalign (void **@var{memptr}, size_t @var{alignment}, size_t @var{size})
1512 Allocate a block of @var{size} bytes, starting on an address that is a
1515 @item void *memalign (size_t @var{size}, size_t @var{boundary})
1516 Allocate a block of @var{size} bytes, starting on an address that is a
1885 general: an obstack can contain any number of objects of any size.  They
1918 obstack}.  This structure has a small fixed size; it records the status
2053 @deftypefun {void *} obstack_alloc (struct obstack *@var{obstack-ptr}, int @var{size})
2059 This allocates an uninitialized block of @var{size} bytes in an obstack
2090 …efun {void *} obstack_copy (struct obstack *@var{obstack-ptr}, void *@var{address}, int @var{size})
2096 This allocates a block and initializes it by copying @var{size}
2102 …fun {void *} obstack_copy0 (struct obstack *@var{obstack-ptr}, void *@var{address}, int @var{size})
2109 character.  This extra byte is not counted in the argument @var{size}.
2118 obstack_savestring (char *addr, int size)
2120   return obstack_copy0 (&myobstack, addr, size);
2201 x = (char *) obstack_alloc (obptr, size);
2203 x = (char *) (obstack_alloc) (obptr, size);
2222 @cindex changing the size of a block (obstacks)
2244 @deftypefun void obstack_blank (struct obstack *@var{obstack-ptr}, int @var{size})
2257 @deftypefun void obstack_grow (struct obstack *@var{obstack-ptr}, void *@var{data}, int @var{size})
2264 the growing-object analogue of @code{obstack_copy}.  It adds @var{size}
2269 @deftypefun void obstack_grow0 (struct obstack *@var{obstack-ptr}, void *@var{data}, int @var{size})
2278 @var{size} bytes copied from @var{data}, followed by an additional null
2337 This function returns the current size of the growing object, in bytes.
2353 You can use @code{obstack_blank} with a negative size argument to make
2415 @deftypefun void obstack_blank_fast (struct obstack *@var{obstack-ptr}, int @var{size})
2419 The function @code{obstack_blank_fast} adds @var{size} bytes to the
2500 This function returns the size in bytes of the currently growing object.
2558 are normally 4096 bytes long unless you specify a different chunk size.
2559 The chunk size includes 8 bytes of overhead that are not actually used
2560 for storing objects.  Regardless of the specified size, longer chunks
2583 If you allocate chunks with @code{malloc}, the chunk size should be a
2584 power of 2.  The default chunk size, 4096, was chosen because it is long
2591 This returns the chunk size of the given obstack.
2594 Since this macro expands to an lvalue, you can specify a new chunk size by
2596 allocated, but will change the size of chunks allocated for that particular
2597 obstack in the future.  It is unlikely to be useful to make the chunk size
2599 allocating many objects whose size is comparable to the chunk size.  Here
2603 if (obstack_chunk_size (obstack_ptr) < @var{new-chunk-size})
2604   obstack_chunk_size (obstack_ptr) = @var{new-chunk-size};
2618 @item void *obstack_alloc (struct obstack *@var{obstack-ptr}, int @var{size})
2619 Allocate an object of @var{size} uninitialized bytes.
2622 @item void *obstack_copy (struct obstack *@var{obstack-ptr}, void *@var{address}, int @var{size})
2623 Allocate an object of @var{size} bytes, with contents copied from
2626 @item void *obstack_copy0 (struct obstack *@var{obstack-ptr}, void *@var{address}, int @var{size})
2627 Allocate an object of @var{size}+1 bytes, with @var{size} of them copied
2635 @item void obstack_blank (struct obstack *@var{obstack-ptr}, int @var{size})
2636 Add @var{size} uninitialized bytes to a growing object.
2639 @item void obstack_grow (struct obstack *@var{obstack-ptr}, void *@var{address}, int @var{size})
2640 Add @var{size} bytes, copied from @var{address}, to a growing object.
2643 @item void obstack_grow0 (struct obstack *@var{obstack-ptr}, void *@var{address}, int @var{size})
2644 Add @var{size} bytes, copied from @var{address}, to a growing object,
2657 Get the current size of the currently growing object.  @xref{Growing
2660 @item void obstack_blank_fast (struct obstack *@var{obstack-ptr}, int @var{size})
2661 Add @var{size} uninitialized bytes to a growing object without checking
2677 The size for allocating chunks.  This is an lvalue.  @xref{Obstack Chunks}.
2692 @cindex automatic storage with variable size
2698 allocate as many blocks as you wish, and compute the size at run time.  But
2707 @deftypefun {void *} alloca (size_t @var{size})
2711 The return value of @code{alloca} is the address of a block of @var{size}
2783 blocks, space used for any size block can be reused for any other size.
2847 variable size.  Here is how @code{open2} would look then:
2863 A variable size array's space is freed at the end of the scope of the
3008 @var{address} must be aligned to the page size for the mapping.  The
3009 system page size can be obtained by calling @code{sysconf} with the
3011 page size is the granularity in which the page protection of anonymous
3014 than the system page size and may require larger alignment.
3018 system page size.
3040 mapping, or @var{length} (after rounding up to the system page size) is
3041 not a multiple of the applicable page size for the mapping, or the
3409 maximum stack size you will need, set it to something, then return from
3423 @code{limits.h} define the macro @code{PAGESIZE} to be the size of a
3640 never changes unless you use @code{realloc} to change its size.  Thus,
3671 @c @deftypefun {void *} r_alloc (void **@var{handleptr}, size_t @var{size})
3672 This function allocates a relocatable block of size @var{size}.  It
3691 @c @deftypefun {void *} r_re_alloc (void **@var{handleptr}, size_t @var{size})
3692 The function @code{r_re_alloc} adjusts the size of the block that
3693 @code{*@var{handleptr}} points to, making it @var{size} bytes long.  It

Last Index update Sun Aug 20 00:31:31 CST 2023