了解malloc.h的区别:__attribute_malloc__ [英] understanding malloc.h difference: __attribute_malloc__

问题描述

有人可以帮助我找到位置或解释__attribute_malloc__的含义吗? 还有__wur?

can someone help me find where or explain what __attribute_malloc__ means? And also __wur?

我正在使用大约120个fortran f77文件的旧代码，但是使用了一些C文件，其中仅使用malloc()，而它们却使用了# include <malloc.h>.

I am working with some old code about 120 fortran f77 files but uses a few C files where it only uses malloc() and they do # include <malloc.h>.

我有kdiff'd stdlib.h和malloc.h;不确定我可以在这两种实现之间找到任何区别吗?

I have kdiff'd stdlib.h and malloc.h; not really sure I can find any difference between the two implementations ?

使用的Linux发行版可以负责/usr/include/malloc.h的内容吗?我正在使用具有GCC 4.3.4的SLES 11.4 x86-64，这里是/usr/include/malloc.h:

Can the linux distribution being used be responsible for the contents of /usr/include/malloc.h? I am using SLES 11.4 x86-64 having GCC 4.3.4 and here is /usr/include/malloc.h :

/* Prototypes and definition for malloc implementation.
   Copyright (C) 1996, 1997, 1999, 2000, 2002-2004, 2005, 2007, 2009
   Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */

#ifndef _MALLOC_H
#define _MALLOC_H 1

#include <features.h>
#include <stddef.h>
#include <stdio.h>

# define __malloc_ptr_t  void *

/* Used by GNU libc internals. */
#define __malloc_size_t size_t
#define __malloc_ptrdiff_t ptrdiff_t

#ifdef __GNUC__

# define __MALLOC_P(args)   args __THROW
/* This macro will be used for functions which might take C++ callback functions.  */
# define __MALLOC_PMT(args) args

#else   /* Not GCC.  */

# define __MALLOC_P(args)   args
# define __MALLOC_PMT(args) args

#endif  /* GCC.  */


__BEGIN_DECLS

/* Allocate SIZE bytes of memory.  */
extern void *malloc __MALLOC_P ((size_t __size)) __attribute_malloc__ __wur;

/* Allocate NMEMB elements of SIZE bytes each, all initialized to 0.  */
extern void *calloc __MALLOC_P ((size_t __nmemb, size_t __size)) __attribute_malloc__ __wur;

/* Re-allocate the previously allocated block in __ptr, making the new block SIZE bytes long.  */
/* __attribute_malloc__ is not used, because if realloc returns
   the same pointer that was passed to it, aliasing needs to be allowed
   between objects pointed by the old and new pointers.  */
extern void *realloc __MALLOC_P ((void *__ptr, size_t __size)) __attribute_warn_unused_result__;

/* Free a block allocated by `malloc', `realloc' or `calloc'.  */
extern void free __MALLOC_P ((void *__ptr));

/* Free a block allocated by `calloc'. */
extern void cfree __MALLOC_P ((void *__ptr));

/* Allocate SIZE bytes allocated to ALIGNMENT bytes.  */
extern void *memalign __MALLOC_P ((size_t __alignment, size_t __size)) __attribute_malloc__ __wur;

/* Allocate SIZE bytes on a page boundary.  */
extern void *valloc __MALLOC_P ((size_t __size)) __attribute_malloc__ __wur;

/* Equivalent to valloc(minimum-page-that-holds(n)), that is, round up __size to nearest pagesize. */
extern void * pvalloc __MALLOC_P ((size_t __size)) __attribute_malloc__ __wur;

/* Underlying allocation function; successive calls should return contiguous pieces of memory.  */
extern void *(*__morecore) __MALLOC_PMT ((ptrdiff_t __size));

/* Default value of `__morecore'.  */
extern void *__default_morecore __MALLOC_P ((ptrdiff_t __size)) __attribute_malloc__;

/* SVID2/XPG mallinfo structure */

struct mallinfo {
  int arena;    /* non-mmapped space allocated from system */
  int ordblks;  /* number of free chunks */
  int smblks;   /* number of fastbin blocks */
  int hblks;    /* number of mmapped regions */
  int hblkhd;   /* space in mmapped regions */
  int usmblks;  /* maximum total allocated space */
  int fsmblks;  /* space available in freed fastbin blocks */
  int uordblks; /* total allocated space */
  int fordblks; /* total free space */
  int keepcost; /* top-most, releasable (via malloc_trim) space */
};

/* Returns a copy of the updated current mallinfo. */
extern struct mallinfo mallinfo __MALLOC_P ((void));

/* SVID2/XPG mallopt options */
#ifndef M_MXFAST
# define M_MXFAST  1    /* maximum request size for "fastbins" */
#endif
#ifndef M_NLBLKS
# define M_NLBLKS  2    /* UNUSED in this malloc */
#endif
#ifndef M_GRAIN
# define M_GRAIN   3    /* UNUSED in this malloc */
#endif
#ifndef M_KEEP
# define M_KEEP    4    /* UNUSED in this malloc */
#endif

/* mallopt options that actually do something */
#define M_TRIM_THRESHOLD    -1
#define M_TOP_PAD           -2
#define M_MMAP_THRESHOLD    -3
#define M_MMAP_MAX          -4
#define M_CHECK_ACTION      -5
#define M_PERTURB       -6
#define M_ARENA_TEST        -7
#define M_ARENA_MAX     -8

/* General SVID/XPG interface to tunable parameters. */
extern int mallopt __MALLOC_P ((int __param, int __val));

/* Release all but __pad bytes of freed top-most memory back to the
   system. Return 1 if successful, else 0. */
extern int malloc_trim __MALLOC_P ((size_t __pad));

/* Report the number of usable allocated bytes associated with allocated chunk __ptr. */
extern size_t malloc_usable_size __MALLOC_P ((void *__ptr));

/* Prints brief summary statistics on stderr. */
extern void malloc_stats __MALLOC_P ((void));

/* Output information about state of allocator to stream FP.  */
extern int malloc_info (int __options, FILE *__fp);

/* Record the state of all malloc variables in an opaque data structure. */
extern void *malloc_get_state __MALLOC_P ((void));

/* Restore the state of all malloc variables from data obtained with malloc_get_state(). */
extern int malloc_set_state __MALLOC_P ((void *__ptr));

/* Called once when malloc is initialized; redefining this variable in
   the application provides the preferred way to set up the hook pointers. */
extern void (*__malloc_initialize_hook) __MALLOC_PMT ((void));

/* Hooks for debugging and user-defined versions. */
extern void (*__free_hook) __MALLOC_PMT ((void *__ptr, __const __malloc_ptr_t));
extern void *(*__malloc_hook) __MALLOC_PMT ((size_t __size, __const __malloc_ptr_t));
extern void *(*__realloc_hook) __MALLOC_PMT ((void *__ptr, size_t __size, __const __malloc_ptr_t));
extern void *(*__memalign_hook) __MALLOC_PMT ((size_t __alignment, size_t __size, __const __malloc_ptr_t));
extern void (*__after_morecore_hook) __MALLOC_PMT ((void));

/* Activate a standard set of debugging hooks. */
extern void __malloc_check_init __MALLOC_P ((void));


__END_DECLS

#endif /* malloc.h */

推荐答案

如果您的代码仅使用标准内存分配接口(malloc，realloc，calloc和free)，则应包括stdlib.h，并且您应该不包含malloc.h. malloc.h是非标准标头，其存在有两个原因:与某些1980年代时代的向后兼容性，预标准化C库以及在其中声明一堆对malloc接口的扩展的地方，因此它们不污染那些不使用命名空间的人. stdlib.h是从中获取内存分配功能的标准位置.它还声明了其他与内存分配无关的其他内容.拿malloc.h和stdlib.h之间的差异不会告诉您任何有用的信息.

If your code uses only the standard memory allocation interfaces (malloc, realloc, calloc, and free), then you should include stdlib.h, and you should not include malloc.h. malloc.h is a nonstandard header which exists for two reasons: backward compatibility with certain 1980s-era, pre-standardization C libraries, and as a place to declare a bunch of extensions to the malloc interface, so that they don't pollute the namespace for people who aren't using them. stdlib.h is the standard place to get the memory allocation functions from. It also declares a bunch of other stuff that isn't related to memory allocation. Taking the diff between malloc.h and stdlib.h will not tell you anything useful.

您不必关心__attribute_malloc__或__wur(或__THROW，或者通常不包含C库头文件中的任何内容，并且其名称以两个下划线开头)的含义.它们是C库使用的注释，用于与C编译器就不是您的问题的事情进行通信. 假定在malloc.h中的malloc声明与stdlib.h中的malloc声明完全相同，包括所有注释；如果不是，那么这是C库中的错误.因为这是您要查看其标题的GNU C库，所以我通常会告诉您在 https上提交错误报告. ://sourceware.org/bugzilla/，但是您引用的malloc.h比当前的开发系列要早十年，而我刚刚检查过，它们在当前的范围内 是相同的开发系列，所以如果有区别，那是因为您的Linux发行版已经过时了，您应该将其处理，而不是上游的GNU libc.

You don't need to care what either __attribute_malloc__ or __wur (or __THROW, or in general anything that's in a C library header, isn't documented, and whose name begins with two underscores) means. They are annotations used by the C library to communicate with the C compiler about things which are Not Your Problem. The declaration of malloc in malloc.h is supposed to be exactly the same as the declaration of malloc in stdlib.h, including any annotations; if they are not, it is a bug in the C library. Since this is the GNU C Library whose headers you're looking at, I would normally tell you to file a bug report at https://sourceware.org/bugzilla/, but the malloc.h you quoted is ten years older than the current development series, and I just checked and they are the same in the current development series, so if there's a difference it is because your Linux distribution is out of date, and you should take that up with them, not with GNU libc upstream.

但是，为了满足您的好奇心，我将告诉您注释的含义. __attribute_malloc__和__wur是在sys/cdefs.h中定义的宏(GNU libc中的每个公共头文件都间接包含了这些宏). __attribute_malloc__扩展为__attribute__ ((__malloc__))，__wur扩展为__attribute__ ((__warn_unused_result__))或什么都没有，具体取决于_FORTIFY_SOURCE的值.

To satisfy your curiosity, however, I will tell you what the annotations mean. __attribute_malloc__ and __wur are macros defined in sys/cdefs.h (which is included, indirectly, by every public header in GNU libc). __attribute_malloc__ expands to __attribute__ ((__malloc__)), and __wur expands to __attribute__ ((__warn_unused_result__)) or to nothing, depending on the value of _FORTIFY_SOURCE.

这两个__attribute__ ((...))构造都记录在 GCC手册中. malloc属性告诉编译器，这是一个类似于malloc的函数，即，该函数返回的指针P不能在该函数返回时别名任何其他有效的指针，而且在该函数中不存在指向有效对象的指针. P寻址的任何存储，这可以帮助优化器节省一点时间. (即使没有声明该声明，GCC的当前版本也已经知道有关malloc的信息，但是较旧的版本则没有.)warn_unused_result属性如果具有此属性的函数的调用者发出警告"不使用其返回值"，这对于malloc来说是一项安全功能，因为如果您调用malloc并且不使用其返回值，则可能会发生内存泄漏.

Both of these __attribute__ ((...)) constructs are documented in the GCC manual. The malloc attribute tells the compiler that this is a function that "is malloc-like, i.e., that the pointer P returned by the function cannot alias any other pointer valid when the function returns, and moreover no pointers to valid objects occur in any storage addressed by P", which helps the optimizer out a bit. (Current versions of GCC already know this about malloc, even if it's declared without that annotation, but older versions didn't.) The warn_unused_result attribute "causes a warning to be emitted if a caller of the function with this attribute does not use its return value", which makes sense as a safety feature for malloc, because if you call malloc and don't use its return value you have a memory leak.

这篇关于了解malloc.h的区别:__attribute_malloc__的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！